{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DAY 44"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 一、预训练的概念"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们之前在训练中发现，准确率最开始随着epoch的增加而增加。随着循环的更新，参数在不断发生更新。\n",
    "\n",
    "所以参数的初始值对训练结果有很大的影响：\n",
    "1. 如果最开始的初始值比较好，后续训练轮数就会少很多\n",
    "2. 很有可能陷入局部最优值，不同的初始值可能导致陷入不同的局部最优值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "所以很自然的想到，如果最开始能有比较好的参数，即可能导致未来训练次数少，也可能导致未来训练避免陷入局部最优解的问题。这就引入了一个概念，即预训练模型。\n",
    "\n",
    "如果别人在某些和我们目标数据类似的大规模数据集上做过训练，我们可以用他的训练参数来初始化我们的模型，这样我们的模型就比较容易收敛。\n",
    "\n",
    "\n",
    "为了帮助你们理解，这里提出几个自问自答的问题。\n",
    "\n",
    "1. 那为什么要选择类似任务的数据集预训练的模型参数呢？\n",
    "\n",
    "因为任务差不多，他提取特征的能力才有用，如果任务相差太大，他的特征提取能力就没那么好。\n",
    "所以本质预训练就是拿别人已经具备的通用特征提取能力来接着强化能力使之更加适应我们的数据集和任务。\n",
    "\n",
    "2. 为什么要求预训练模型是在大规模数据集上训练的，小规模不行么？\n",
    "因为提取的是通用特征，所以如果数据集数据少、尺寸小，就很难支撑复杂任务学习通用的数据特征。比如你是一个物理的博士，让你去做小学数学题，很快就能上手；但是你是一个小学数学速算高手，让你做物理博士的课题，就很困难。所以预训练模型一般就挺强的。\n",
    "\n",
    "我们把用预训练模型的参数，然后接着在自己数据集上训练来调整该参数的过程叫做微调，这种思想叫做迁移学习。把预训练的过程叫做上游任务，把微调的过程叫做下游任务。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在再来看下之前一直用的cifar10数据集，他是不是就很明显不适合作为预训练数据集？\n",
    "1. 规模过小：仅 10 万张图像，且尺寸小（32x32），无法支撑复杂模型学习通用视觉特征；\n",
    "2. 类别单一：仅 10 类（飞机、汽车等），泛化能力有限；\n",
    "\n",
    "这里给大家介绍一个常常用来做预训练的数据集，ImageNet，ImageNet 1000 个类别，有 1.2 亿张图像，尺寸 224x224，数据集大小 1.4G，下载地址：http://www.image-net.org/。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 二、 经典的预训练模型\n",
    "### 2.1 CNN架构预训练模型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "| 模型       | 预训练数据集 | 核心特点                                   | 在CIFAR10上的适配要点                     |  \n",
    "|------------|--------------|--------------------------------------------|-------------------------------------------|  \n",
    "| **AlexNet** | ImageNet     | 首次引入ReLU/局部响应归一化，参数量6000万+ | 需修改首层卷积核大小（原11x11→适配32x32） |  \n",
    "| **VGG16**   | ImageNet     | 纯卷积堆叠，结构统一，参数量1.38亿        | 冻结前10层卷积，仅微调全连接层            |  \n",
    "| **ResNet18** | ImageNet     | 残差连接解决梯度消失，参数量1100万        | 直接适配32x32输入，需调整池化层步长       |  \n",
    "| **MobileNetV2** | ImageNet  | 深度可分离卷积，参数量350万+              | 轻量级设计，适合计算资源有限的场景        |  \n",
    "\n",
    "### 2.2 Transformer类预训练模型  \n",
    "适用于较大尺图像（如224x224），在CIFAR10上需**上采样图像尺寸**或**调整Patch大小**。   \n",
    "| 模型       | 预训练数据集 | 核心特点                                   | 在CIFAR10上的适配要点                     |  \n",
    "|------------|--------------|--------------------------------------------|-------------------------------------------|  \n",
    "| **ViT-Base** | ImageNet-21K| 纯Transformer架构，参数量8600万           | 图像Resize至224x224，Patch大小设为4x4      |  \n",
    "| **Swin Transformer** | ImageNet-22K | 分层窗口注意力，参数量8000万+             | 需调整窗口大小适配小图像                  |  \n",
    "| **DeiT**     | ImageNet     | 结合CNN归纳偏置，参数量2200万             | 轻量级Transformer，适合中小尺寸图像        |  \n",
    "\n",
    "### 2.3 自监督预训练模型  \n",
    "无需人工标注，通过 pretext task（如掩码图像重建）学习特征，适合数据稀缺场景。  \n",
    "| 模型       | 预训练方式       | 典型数据集   | 在CIFAR10上的优势                 |  \n",
    "|------------|------------------|--------------|-----------------------------------|  \n",
    "| **MoCo v3** | 对比学习         | ImageNet     | 无需标签即可迁移，适合无标注数据  |  \n",
    "| **BEiT**    | 掩码图像建模     | ImageNet-22K| 特征语义丰富，微调时收敛更快      |  \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 三、常见的分类预训练模型介绍"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 预训练模型的发展史"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "| **模型**       | **年份** | **提出团队**       | **关键创新点**                                                                 | **层数** | **参数量** | **ImageNet Top-5错误率** | **典型应用场景**               | **预训练权重可用性**         |\n",
    "|----------------|----------|--------------------|--------------------------------------------------------------------------------|----------|------------|--------------------------|------------------------------|------------------------------|\n",
    "| **LeNet-5**    | 1998     | Yann LeCun等       | 首个CNN架构，卷积层+池化层+全连接层，Sigmoid激活函数                          | 7        | ~60K       | N/A                      | 手写数字识别（MNIST）         | 无（历史模型）               |\n",
    "| **AlexNet**    | 2012     | Alex Krizhevsky等  | ReLU激活函数、Dropout、数据增强、GPU训练                                        | 8        | 60M        | 15.3%                    | 大规模图像分类               | PyTorch/TensorFlow官方支持   |\n",
    "| **VGGNet**     | 2014     | Oxford VGG团队     | 统一3×3卷积核、多尺度特征提取、结构简洁                                         | 16/19    | 138M/144M  | 7.3%/7.0%                | 图像分类、目标检测基础骨干网络 | PyTorch/TensorFlow官方支持   |\n",
    "| **GoogLeNet**  | 2014     | Google             | Inception模块（多分支并行卷积）、1×1卷积降维、全局平均池化                     | 22       | 5M         | 6.7%                     | 大规模图像分类               | PyTorch/TensorFlow官方支持   |\n",
    "| **ResNet**     | 2015     | 何恺明等           | 残差连接（解决梯度消失）、Batch Normalization                                   | 18/50/152| 11M/25M/60M | 3.57%/3.63%/3.58%        | 图像/视频分类、检测、分割     | PyTorch/TensorFlow官方支持   |\n",
    "| **DenseNet**   | 2017     | Gao Huang等        | 密集连接（每层与后续所有层相连）、特征复用、参数效率高                         | 121/169  | 8M/14M     | 2.80%                    | 小数据集、医学图像处理        | PyTorch/TensorFlow官方支持   |\n",
    "| **MobileNet**  | 2017     | Google             | 深度可分离卷积（减少75%计算量）、轻量级设计                                     | 28       | 4.2M       | 7.4%                     | 移动端图像分类/检测           | PyTorch/TensorFlow官方支持   |\n",
    "| **EfficientNet** | 2019   | Google             | 复合缩放（同时优化深度、宽度、分辨率）、NAS搜索最佳配置                         | B0-B7    | 5.3M-66M   | 2.6% (B7)                | 高精度图像分类（资源受限场景）| PyTorch/TensorFlow官方支持   |\n",
    "\n",
    "上图的层数，代表该模型不同的版本resnet有resnet18、resnet50、resnet152；efficientnet有efficientnet-b0、efficientnet-b1、efficientnet-b2、efficientnet-b3、efficientnet-b4等\n",
    "\n",
    "\n",
    "其中ImageNet Top - 5 准确率是图像分类任务里的一种评估指标 ，用于衡量模型在 ImageNet 数据集上的分类性能，模型对图像进行分类预测，输出所有类别（共 1000 类 ）的概率，取概率排名前五的类别，只要这五个类别里包含人工标注的正确类别，就算预测正确。\n",
    "\n",
    "模型架构演进关键点总结\n",
    "\n",
    "1. **深度突破**：从LeNet的7层到ResNet152的152层，残差连接解决了深度网络的训练难题。  ----没上过我复试班cv部分的自行去了解下什么叫做残差连接，很重要！\n",
    "2. **计算效率**：GoogLeNet（Inception）和MobileNet通过结构优化，在保持精度的同时大幅降低参数量。  \n",
    "3. **特征复用**：DenseNet的密集连接设计使模型能更好地利用浅层特征，适合小数据集。  \n",
    "4. **自动化设计**：EfficientNet使用神经架构搜索（NAS）自动寻找最优网络配置，开创了AutoML在CNN中的应用。  \n",
    "\n",
    "\n",
    "预训练模型使用建议\n",
    "\n",
    "| **任务需求**               | **推荐模型**       | **理由**                                                                 |\n",
    "|----------------------------|--------------------|--------------------------------------------------------------------------|\n",
    "| 快速原型开发               | ResNet50/18        | 结构平衡，预训练权重稳定，社区支持完善                                   |\n",
    "| 移动端部署                 | MobileNetV3        | 参数量小，计算高效，专为移动设备优化                                     |\n",
    "| 高精度分类（资源充足）     | EfficientNet-B7    | 目前ImageNet准确率领先，适合GPU/TPU环境                                 |\n",
    "| 小数据集或特征复用需求     | DenseNet           | 密集连接设计减少过拟合，特征复用能力强                                   |\n",
    "| 多尺度特征提取             | Inception-ResNet   | 结合Inception多分支和ResNet残差连接，适合复杂场景                        |\n",
    "\n",
    "这些模型的预训练权重均可通过主流框架（如PyTorch的`torchvision.models`、Keras的`applications`模块）直接加载，便于快速迁移到新任务。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "总结：CNN 架构发展脉络\n",
    "1. 早期探索（1990s-2010s）：LeNet 验证 CNN 可行性，但受限于计算和数据。\n",
    "2. 深度学习复兴（2012-2015）：AlexNet、VGGNet、GoogLeNet 通过加深网络和结构创新突破性能。\n",
    "3. 超深网络时代（2015 年后）：ResNet 解决退化问题，开启残差连接范式，后续模型围绕效率（MobileNet）、特征复用（DenseNet）、多分支结构（Inception）等方向优化。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 预训练模型的训练策略"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "那么什么模型会被选为预训练模型呢？比如一些调参后表现很好的cnn神经网络（固定的神经元个数+固定的层数等）。\n",
    "\n",
    "所以调用预训练模型做微调，本质就是 用这些固定的结构+之前训练好的参数 接着训练\n",
    "\n",
    "所以需要找到预训练的模型结构并且加载模型参数\n",
    "\n",
    "相较于之前用自己定义的模型有以下几个注意点"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. 需要调用预训练模型和加载权重\n",
    "2. 需要resize 图片让其可以适配模型\n",
    "3. 需要修改最后的全连接层以适应数据集\n",
    "\n",
    "其中，训练过程中，为了不破坏最开始的特征提取器的参数，最开始往往先冻结住特征提取器的参数，然后训练全连接层，大约在5-10个epoch后解冻训练。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "主要做特征提取的部分叫做backbone骨干网络；负责融合提取的特征的部分叫做Featue Pyramid Network（FPN）；负责输出的预测部分的叫做Head。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先复用下之前的代码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "使用设备: cuda\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torchvision import datasets, transforms\n",
    "from torch.utils.data import DataLoader\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 设置中文字体支持\n",
    "plt.rcParams[\"font.family\"] = [\"SimHei\"]\n",
    "plt.rcParams['axes.unicode_minus'] = False  # 解决负号显示问题\n",
    "\n",
    "# 检查GPU是否可用\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"使用设备: {device}\")\n",
    "\n",
    "# 1. 数据预处理（训练集增强，测试集标准化）\n",
    "train_transform = transforms.Compose([\n",
    "    transforms.RandomCrop(32, padding=4),\n",
    "    transforms.RandomHorizontalFlip(),\n",
    "    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),\n",
    "    transforms.RandomRotation(15),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))\n",
    "])\n",
    "\n",
    "test_transform = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))\n",
    "])\n",
    "\n",
    "# 2. 加载CIFAR-10数据集\n",
    "train_dataset = datasets.CIFAR10(\n",
    "    root='./data',\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=train_transform\n",
    ")\n",
    "\n",
    "test_dataset = datasets.CIFAR10(\n",
    "    root='./data',\n",
    "    train=False,\n",
    "    transform=test_transform\n",
    ")\n",
    "\n",
    "# 3. 创建数据加载器（可调整batch_size）\n",
    "batch_size = 64\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "# 4. 训练函数（支持学习率调度器）\n",
    "def train(model, train_loader, test_loader, criterion, optimizer, scheduler, device, epochs):\n",
    "    model.train()  # 设置为训练模式\n",
    "    train_loss_history = []\n",
    "    test_loss_history = []\n",
    "    train_acc_history = []\n",
    "    test_acc_history = []\n",
    "    all_iter_losses = []\n",
    "    iter_indices = []\n",
    "\n",
    "    for epoch in range(epochs):\n",
    "        running_loss = 0.0\n",
    "        correct_train = 0\n",
    "        total_train = 0\n",
    "        \n",
    "        for batch_idx, (data, target) in enumerate(train_loader):\n",
    "            data, target = data.to(device), target.to(device)\n",
    "            optimizer.zero_grad()\n",
    "            output = model(data)\n",
    "            loss = criterion(output, target)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            \n",
    "            # 记录Iteration损失\n",
    "            iter_loss = loss.item()\n",
    "            all_iter_losses.append(iter_loss)\n",
    "            iter_indices.append(epoch * len(train_loader) + batch_idx + 1)\n",
    "            \n",
    "            # 统计训练指标\n",
    "            running_loss += iter_loss\n",
    "            _, predicted = output.max(1)\n",
    "            total_train += target.size(0)\n",
    "            correct_train += predicted.eq(target).sum().item()\n",
    "            \n",
    "            # 每100批次打印进度\n",
    "            if (batch_idx + 1) % 100 == 0:\n",
    "                print(f\"Epoch {epoch+1}/{epochs} | Batch {batch_idx+1}/{len(train_loader)} \"\n",
    "                      f\"| 单Batch损失: {iter_loss:.4f}\")\n",
    "        \n",
    "        # 计算 epoch 级指标\n",
    "        epoch_train_loss = running_loss / len(train_loader)\n",
    "        epoch_train_acc = 100. * correct_train / total_train\n",
    "        \n",
    "        # 测试阶段\n",
    "        model.eval()\n",
    "        correct_test = 0\n",
    "        total_test = 0\n",
    "        test_loss = 0.0\n",
    "        with torch.no_grad():\n",
    "            for data, target in test_loader:\n",
    "                data, target = data.to(device), target.to(device)\n",
    "                output = model(data)\n",
    "                test_loss += criterion(output, target).item()\n",
    "                _, predicted = output.max(1)\n",
    "                total_test += target.size(0)\n",
    "                correct_test += predicted.eq(target).sum().item()\n",
    "        \n",
    "        epoch_test_loss = test_loss / len(test_loader)\n",
    "        epoch_test_acc = 100. * correct_test / total_test\n",
    "        \n",
    "        # 记录历史数据\n",
    "        train_loss_history.append(epoch_train_loss)\n",
    "        test_loss_history.append(epoch_test_loss)\n",
    "        train_acc_history.append(epoch_train_acc)\n",
    "        test_acc_history.append(epoch_test_acc)\n",
    "        \n",
    "        # 更新学习率调度器\n",
    "        if scheduler is not None:\n",
    "            scheduler.step(epoch_test_loss)\n",
    "        \n",
    "        # 打印 epoch 结果\n",
    "        print(f\"Epoch {epoch+1} 完成 | 训练损失: {epoch_train_loss:.4f} \"\n",
    "              f\"| 训练准确率: {epoch_train_acc:.2f}% | 测试准确率: {epoch_test_acc:.2f}%\")\n",
    "    \n",
    "    # 绘制损失和准确率曲线\n",
    "    plot_iter_losses(all_iter_losses, iter_indices)\n",
    "    plot_epoch_metrics(train_acc_history, test_acc_history, train_loss_history, test_loss_history)\n",
    "    \n",
    "    return epoch_test_acc  # 返回最终测试准确率\n",
    "\n",
    "# 5. 绘制Iteration损失曲线\n",
    "def plot_iter_losses(losses, indices):\n",
    "    plt.figure(figsize=(10, 4))\n",
    "    plt.plot(indices, losses, 'b-', alpha=0.7)\n",
    "    plt.xlabel('Iteration（Batch序号）')\n",
    "    plt.ylabel('损失值')\n",
    "    plt.title('训练过程中的Iteration损失变化')\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "# 6. 绘制Epoch级指标曲线\n",
    "def plot_epoch_metrics(train_acc, test_acc, train_loss, test_loss):\n",
    "    epochs = range(1, len(train_acc) + 1)\n",
    "    \n",
    "    plt.figure(figsize=(12, 5))\n",
    "    \n",
    "    # 准确率曲线\n",
    "    plt.subplot(1, 2, 1)\n",
    "    plt.plot(epochs, train_acc, 'b-', label='训练准确率')\n",
    "    plt.plot(epochs, test_acc, 'r-', label='测试准确率')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('准确率 (%)')\n",
    "    plt.title('准确率随Epoch变化')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    \n",
    "    # 损失曲线\n",
    "    plt.subplot(1, 2, 2)\n",
    "    plt.plot(epochs, train_loss, 'b-', label='训练损失')\n",
    "    plt.plot(epochs, test_loss, 'r-', label='测试损失')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('损失值')\n",
    "    plt.title('损失值随Epoch变化')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入ResNet模型\n",
    "from torchvision.models import resnet18\n",
    "\n",
    "# 定义ResNet18模型（支持预训练权重加载）\n",
    "def create_resnet18(pretrained=True, num_classes=10):\n",
    "    # 加载预训练模型（ImageNet权重）\n",
    "    model = resnet18(pretrained=pretrained)\n",
    "    \n",
    "    # 修改最后一层全连接层，适配CIFAR-10的10分类任务\n",
    "    in_features = model.fc.in_features\n",
    "    model.fc = nn.Linear(in_features, num_classes)\n",
    "    \n",
    "    # 将模型转移到指定设备（CPU/GPU）\n",
    "    model = model.to(device)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 创建ResNet18模型（加载ImageNet预训练权重，不进行微调）\n",
    "model = create_resnet18(pretrained=True, num_classes=10)\n",
    "model.eval()  # 设置为推理模式\n",
    "\n",
    "# 测试单张图片（示例）\n",
    "from torchvision import utils\n",
    "\n",
    "# 从测试数据集中获取一张图片\n",
    "dataiter = iter(test_loader)\n",
    "images, labels = dataiter.next()\n",
    "images = images[:1].to(device)  # 取第1张图片\n",
    "\n",
    "# 前向传播\n",
    "with torch.no_grad():\n",
    "    outputs = model(images)\n",
    "    _, predicted = torch.max(outputs.data, 1)\n",
    "\n",
    "# 显示图片和预测结果\n",
    "plt.imshow(utils.make_grid(images.cpu(), normalize=True).permute(1, 2, 0))\n",
    "plt.title(f\"预测类别: {predicted.item()}\")\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在 **CIFAR-10 数据集** 中，类别标签是固定的 10 个，分别对应：\n",
    "\n",
    "| 标签（数字） | 类别名称       | 说明                     |\n",
    "|--------------|----------------|--------------------------|\n",
    "| 0            | airplane       | 飞机                     |\n",
    "| 1            | automobile     | 汽车（含轿车、卡车等）   |\n",
    "| 2            | bird           | 鸟类                     |\n",
    "| 3            | cat            | 猫                       |\n",
    "| 4            | deer           | 鹿                       |\n",
    "| 5            | dog            | 狗                       |\n",
    "| 6            | frog           | 青蛙                     |\n",
    "| 7            | horse          | 马                       |\n",
    "| 8            | ship           | 船                       |\n",
    "| 9            | truck          | 卡车（重型货车等）       |\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "使用设备: cuda\n",
      "Files already downloaded and verified\n",
      "已冻结模型卷积层参数 (11176512/11181642 参数)\n",
      "Epoch 1/40 | Batch 100/782 | 单Batch损失: 2.2746\n",
      "Epoch 1/40 | Batch 200/782 | 单Batch损失: 2.0283\n",
      "Epoch 1/40 | Batch 300/782 | 单Batch损失: 1.7735\n",
      "Epoch 1/40 | Batch 400/782 | 单Batch损失: 1.9917\n",
      "Epoch 1/40 | Batch 500/782 | 单Batch损失: 1.6662\n",
      "Epoch 1/40 | Batch 600/782 | 单Batch损失: 1.8309\n",
      "Epoch 1/40 | Batch 700/782 | 单Batch损失: 1.7485\n",
      "Epoch 1 完成 | 训练损失: 1.9633 | 训练准确率: 29.96% | 测试准确率: 32.28%\n",
      "Epoch 2/40 | Batch 100/782 | 单Batch损失: 1.9622\n",
      "Epoch 2/40 | Batch 200/782 | 单Batch损失: 1.9096\n",
      "Epoch 2/40 | Batch 300/782 | 单Batch损失: 1.9117\n",
      "Epoch 2/40 | Batch 400/782 | 单Batch损失: 1.6654\n",
      "Epoch 2/40 | Batch 500/782 | 单Batch损失: 1.8214\n",
      "Epoch 2/40 | Batch 600/782 | 单Batch损失: 2.0345\n",
      "Epoch 2/40 | Batch 700/782 | 单Batch损失: 2.1190\n",
      "Epoch 2 完成 | 训练损失: 1.8675 | 训练准确率: 33.81% | 测试准确率: 32.79%\n",
      "Epoch 3/40 | Batch 100/782 | 单Batch损失: 1.7294\n",
      "Epoch 3/40 | Batch 200/782 | 单Batch损失: 1.8884\n",
      "Epoch 3/40 | Batch 300/782 | 单Batch损失: 2.0095\n",
      "Epoch 3/40 | Batch 400/782 | 单Batch损失: 1.7234\n",
      "Epoch 3/40 | Batch 500/782 | 单Batch损失: 1.8481\n",
      "Epoch 3/40 | Batch 600/782 | 单Batch损失: 1.8441\n",
      "Epoch 3/40 | Batch 700/782 | 单Batch损失: 2.0066\n",
      "Epoch 3 完成 | 训练损失: 1.8540 | 训练准确率: 34.40% | 测试准确率: 34.65%\n",
      "Epoch 4/40 | Batch 100/782 | 单Batch损失: 1.9432\n",
      "Epoch 4/40 | Batch 200/782 | 单Batch损失: 1.6196\n",
      "Epoch 4/40 | Batch 300/782 | 单Batch损失: 1.7874\n",
      "Epoch 4/40 | Batch 400/782 | 单Batch损失: 1.8416\n",
      "Epoch 4/40 | Batch 500/782 | 单Batch损失: 1.9233\n",
      "Epoch 4/40 | Batch 600/782 | 单Batch损失: 1.7665\n",
      "Epoch 4/40 | Batch 700/782 | 单Batch损失: 1.9478\n",
      "Epoch 4 完成 | 训练损失: 1.8512 | 训练准确率: 34.39% | 测试准确率: 34.35%\n",
      "Epoch 5/40 | Batch 100/782 | 单Batch损失: 2.0171\n",
      "Epoch 5/40 | Batch 200/782 | 单Batch损失: 1.7849\n",
      "Epoch 5/40 | Batch 300/782 | 单Batch损失: 1.8292\n",
      "Epoch 5/40 | Batch 400/782 | 单Batch损失: 1.9803\n",
      "Epoch 5/40 | Batch 500/782 | 单Batch损失: 1.6365\n",
      "Epoch 5/40 | Batch 600/782 | 单Batch损失: 1.9088\n",
      "Epoch 5/40 | Batch 700/782 | 单Batch损失: 1.8456\n",
      "Epoch 5 完成 | 训练损失: 1.8486 | 训练准确率: 34.38% | 测试准确率: 34.29%\n",
      "已解冻模型所有参数 (11181642/11181642 参数可训练)\n",
      "Epoch 6/40 | Batch 100/782 | 单Batch损失: 1.4501\n",
      "Epoch 6/40 | Batch 200/782 | 单Batch损失: 0.9866\n",
      "Epoch 6/40 | Batch 300/782 | 单Batch损失: 1.3025\n",
      "Epoch 6/40 | Batch 400/782 | 单Batch损失: 1.1481\n",
      "Epoch 6/40 | Batch 500/782 | 单Batch损失: 1.2977\n",
      "Epoch 6/40 | Batch 600/782 | 单Batch损失: 1.1055\n",
      "Epoch 6/40 | Batch 700/782 | 单Batch损失: 1.0491\n",
      "Epoch 6 完成 | 训练损失: 1.2998 | 训练准确率: 54.22% | 测试准确率: 67.23%\n",
      "Epoch 7/40 | Batch 100/782 | 单Batch损失: 1.1548\n",
      "Epoch 7/40 | Batch 200/782 | 单Batch损失: 0.9465\n",
      "Epoch 7/40 | Batch 300/782 | 单Batch损失: 0.9650\n",
      "Epoch 7/40 | Batch 400/782 | 单Batch损失: 0.6820\n",
      "Epoch 7/40 | Batch 500/782 | 单Batch损失: 0.8018\n",
      "Epoch 7/40 | Batch 600/782 | 单Batch损失: 0.9235\n",
      "Epoch 7/40 | Batch 700/782 | 单Batch损失: 0.9785\n",
      "Epoch 7 完成 | 训练损失: 0.9831 | 训练准确率: 65.82% | 测试准确率: 73.35%\n",
      "Epoch 8/40 | Batch 100/782 | 单Batch损失: 1.0422\n",
      "Epoch 8/40 | Batch 200/782 | 单Batch损失: 0.8977\n",
      "Epoch 8/40 | Batch 300/782 | 单Batch损失: 0.9675\n",
      "Epoch 8/40 | Batch 400/782 | 单Batch损失: 0.7166\n",
      "Epoch 8/40 | Batch 500/782 | 单Batch损失: 0.8461\n",
      "Epoch 8/40 | Batch 600/782 | 单Batch损失: 0.9074\n",
      "Epoch 8/40 | Batch 700/782 | 单Batch损失: 0.6013\n",
      "Epoch 8 完成 | 训练损失: 0.8601 | 训练准确率: 69.97% | 测试准确率: 76.02%\n",
      "Epoch 9/40 | Batch 100/782 | 单Batch损失: 0.7530\n",
      "Epoch 9/40 | Batch 200/782 | 单Batch损失: 1.2476\n",
      "Epoch 9/40 | Batch 300/782 | 单Batch损失: 0.8363\n",
      "Epoch 9/40 | Batch 400/782 | 单Batch损失: 0.7913\n",
      "Epoch 9/40 | Batch 500/782 | 单Batch损失: 0.5406\n",
      "Epoch 9/40 | Batch 600/782 | 单Batch损失: 0.8790\n",
      "Epoch 9/40 | Batch 700/782 | 单Batch损失: 0.8013\n",
      "Epoch 9 完成 | 训练损失: 0.7942 | 训练准确率: 72.51% | 测试准确率: 78.50%\n",
      "Epoch 10/40 | Batch 100/782 | 单Batch损失: 0.6242\n",
      "Epoch 10/40 | Batch 200/782 | 单Batch损失: 0.7985\n",
      "Epoch 10/40 | Batch 300/782 | 单Batch损失: 0.8187\n",
      "Epoch 10/40 | Batch 400/782 | 单Batch损失: 0.8442\n",
      "Epoch 10/40 | Batch 500/782 | 单Batch损失: 0.7636\n",
      "Epoch 10/40 | Batch 600/782 | 单Batch损失: 0.6356\n",
      "Epoch 10/40 | Batch 700/782 | 单Batch损失: 0.7811\n",
      "Epoch 10 完成 | 训练损失: 0.7466 | 训练准确率: 74.18% | 测试准确率: 80.30%\n",
      "Epoch 11/40 | Batch 100/782 | 单Batch损失: 0.5778\n",
      "Epoch 11/40 | Batch 200/782 | 单Batch损失: 0.6424\n",
      "Epoch 11/40 | Batch 300/782 | 单Batch损失: 0.6740\n",
      "Epoch 11/40 | Batch 400/782 | 单Batch损失: 0.6944\n",
      "Epoch 11/40 | Batch 500/782 | 单Batch损失: 0.8197\n",
      "Epoch 11/40 | Batch 600/782 | 单Batch损失: 0.7754\n",
      "Epoch 11/40 | Batch 700/782 | 单Batch损失: 0.6164\n",
      "Epoch 11 完成 | 训练损失: 0.7096 | 训练准确率: 75.35% | 测试准确率: 80.29%\n",
      "Epoch 12/40 | Batch 100/782 | 单Batch损失: 0.6795\n",
      "Epoch 12/40 | Batch 200/782 | 单Batch损失: 0.5132\n",
      "Epoch 12/40 | Batch 300/782 | 单Batch损失: 0.5526\n",
      "Epoch 12/40 | Batch 400/782 | 单Batch损失: 0.5981\n",
      "Epoch 12/40 | Batch 500/782 | 单Batch损失: 0.6312\n",
      "Epoch 12/40 | Batch 600/782 | 单Batch损失: 0.5807\n",
      "Epoch 12/40 | Batch 700/782 | 单Batch损失: 0.8097\n",
      "Epoch 12 完成 | 训练损失: 0.6747 | 训练准确率: 76.43% | 测试准确率: 80.95%\n",
      "Epoch 13/40 | Batch 100/782 | 单Batch损失: 0.5757\n",
      "Epoch 13/40 | Batch 200/782 | 单Batch损失: 0.5791\n",
      "Epoch 13/40 | Batch 300/782 | 单Batch损失: 0.5037\n",
      "Epoch 13/40 | Batch 400/782 | 单Batch损失: 0.7592\n",
      "Epoch 13/40 | Batch 500/782 | 单Batch损失: 0.8742\n",
      "Epoch 13/40 | Batch 600/782 | 单Batch损失: 0.7225\n",
      "Epoch 13/40 | Batch 700/782 | 单Batch损失: 0.6084\n",
      "Epoch 13 完成 | 训练损失: 0.6451 | 训练准确率: 77.64% | 测试准确率: 81.31%\n",
      "Epoch 14/40 | Batch 100/782 | 单Batch损失: 0.6919\n",
      "Epoch 14/40 | Batch 200/782 | 单Batch损失: 0.5774\n",
      "Epoch 14/40 | Batch 300/782 | 单Batch损失: 0.5386\n",
      "Epoch 14/40 | Batch 400/782 | 单Batch损失: 0.7253\n",
      "Epoch 14/40 | Batch 500/782 | 单Batch损失: 0.4620\n",
      "Epoch 14/40 | Batch 600/782 | 单Batch损失: 0.6363\n",
      "Epoch 14/40 | Batch 700/782 | 单Batch损失: 0.4766\n",
      "Epoch 14 完成 | 训练损失: 0.6262 | 训练准确率: 78.27% | 测试准确率: 81.57%\n",
      "Epoch 15/40 | Batch 100/782 | 单Batch损失: 0.5209\n",
      "Epoch 15/40 | Batch 200/782 | 单Batch损失: 0.7623\n",
      "Epoch 15/40 | Batch 300/782 | 单Batch损失: 0.5972\n",
      "Epoch 15/40 | Batch 400/782 | 单Batch损失: 0.5153\n",
      "Epoch 15/40 | Batch 500/782 | 单Batch损失: 0.4694\n",
      "Epoch 15/40 | Batch 600/782 | 单Batch损失: 0.6652\n",
      "Epoch 15/40 | Batch 700/782 | 单Batch损失: 0.8098\n",
      "Epoch 15 完成 | 训练损失: 0.6035 | 训练准确率: 78.94% | 测试准确率: 82.69%\n",
      "Epoch 16/40 | Batch 100/782 | 单Batch损失: 0.3695\n",
      "Epoch 16/40 | Batch 200/782 | 单Batch损失: 0.5164\n",
      "Epoch 16/40 | Batch 300/782 | 单Batch损失: 0.4680\n",
      "Epoch 16/40 | Batch 400/782 | 单Batch损失: 0.7711\n",
      "Epoch 16/40 | Batch 500/782 | 单Batch损失: 0.5883\n",
      "Epoch 16/40 | Batch 600/782 | 单Batch损失: 0.3142\n",
      "Epoch 16/40 | Batch 700/782 | 单Batch损失: 0.5261\n",
      "Epoch 16 完成 | 训练损失: 0.5852 | 训练准确率: 79.62% | 测试准确率: 82.86%\n",
      "Epoch 17/40 | Batch 100/782 | 单Batch损失: 0.6548\n",
      "Epoch 17/40 | Batch 200/782 | 单Batch损失: 0.8322\n",
      "Epoch 17/40 | Batch 300/782 | 单Batch损失: 0.5157\n",
      "Epoch 17/40 | Batch 400/782 | 单Batch损失: 0.4902\n",
      "Epoch 17/40 | Batch 500/782 | 单Batch损失: 0.9218\n",
      "Epoch 17/40 | Batch 600/782 | 单Batch损失: 0.6169\n",
      "Epoch 17/40 | Batch 700/782 | 单Batch损失: 0.3676\n",
      "Epoch 17 完成 | 训练损失: 0.5620 | 训练准确率: 80.46% | 测试准确率: 83.46%\n",
      "Epoch 18/40 | Batch 100/782 | 单Batch损失: 0.5617\n",
      "Epoch 18/40 | Batch 200/782 | 单Batch损失: 0.5368\n",
      "Epoch 18/40 | Batch 300/782 | 单Batch损失: 0.3711\n",
      "Epoch 18/40 | Batch 400/782 | 单Batch损失: 0.6305\n",
      "Epoch 18/40 | Batch 500/782 | 单Batch损失: 0.8022\n",
      "Epoch 18/40 | Batch 600/782 | 单Batch损失: 0.3864\n",
      "Epoch 18/40 | Batch 700/782 | 单Batch损失: 0.3906\n",
      "Epoch 18 完成 | 训练损失: 0.5511 | 训练准确率: 80.82% | 测试准确率: 83.58%\n",
      "Epoch 19/40 | Batch 100/782 | 单Batch损失: 0.5529\n",
      "Epoch 19/40 | Batch 200/782 | 单Batch损失: 0.5140\n",
      "Epoch 19/40 | Batch 300/782 | 单Batch损失: 0.5248\n",
      "Epoch 19/40 | Batch 400/782 | 单Batch损失: 0.5481\n",
      "Epoch 19/40 | Batch 500/782 | 单Batch损失: 0.5130\n",
      "Epoch 19/40 | Batch 600/782 | 单Batch损失: 0.5096\n",
      "Epoch 19/40 | Batch 700/782 | 单Batch损失: 0.4920\n",
      "Epoch 19 完成 | 训练损失: 0.5346 | 训练准确率: 81.38% | 测试准确率: 83.39%\n",
      "Epoch 20/40 | Batch 100/782 | 单Batch损失: 0.4986\n",
      "Epoch 20/40 | Batch 200/782 | 单Batch损失: 0.4441\n",
      "Epoch 20/40 | Batch 300/782 | 单Batch损失: 0.5545\n",
      "Epoch 20/40 | Batch 400/782 | 单Batch损失: 0.6198\n",
      "Epoch 20/40 | Batch 500/782 | 单Batch损失: 0.6450\n",
      "Epoch 20/40 | Batch 600/782 | 单Batch损失: 0.7414\n",
      "Epoch 20/40 | Batch 700/782 | 单Batch损失: 0.5779\n",
      "Epoch 20 完成 | 训练损失: 0.5207 | 训练准确率: 81.76% | 测试准确率: 83.81%\n",
      "Epoch 21/40 | Batch 100/782 | 单Batch损失: 0.6586\n",
      "Epoch 21/40 | Batch 200/782 | 单Batch损失: 0.4860\n",
      "Epoch 21/40 | Batch 300/782 | 单Batch损失: 0.6694\n",
      "Epoch 21/40 | Batch 400/782 | 单Batch损失: 0.7057\n",
      "Epoch 21/40 | Batch 500/782 | 单Batch损失: 0.5195\n",
      "Epoch 21/40 | Batch 600/782 | 单Batch损失: 0.6519\n",
      "Epoch 21/40 | Batch 700/782 | 单Batch损失: 0.4956\n",
      "Epoch 21 完成 | 训练损失: 0.5018 | 训练准确率: 82.49% | 测试准确率: 83.52%\n",
      "Epoch 22/40 | Batch 100/782 | 单Batch损失: 0.6390\n",
      "Epoch 22/40 | Batch 200/782 | 单Batch损失: 0.4532\n",
      "Epoch 22/40 | Batch 300/782 | 单Batch损失: 0.4574\n",
      "Epoch 22/40 | Batch 400/782 | 单Batch损失: 0.7280\n",
      "Epoch 22/40 | Batch 500/782 | 单Batch损失: 0.5452\n",
      "Epoch 22/40 | Batch 600/782 | 单Batch损失: 0.5946\n",
      "Epoch 22/40 | Batch 700/782 | 单Batch损失: 0.5525\n",
      "Epoch 22 完成 | 训练损失: 0.4916 | 训练准确率: 82.60% | 测试准确率: 84.31%\n",
      "Epoch 23/40 | Batch 100/782 | 单Batch损失: 0.4012\n",
      "Epoch 23/40 | Batch 200/782 | 单Batch损失: 0.3825\n",
      "Epoch 23/40 | Batch 300/782 | 单Batch损失: 0.4821\n",
      "Epoch 23/40 | Batch 400/782 | 单Batch损失: 0.4401\n",
      "Epoch 23/40 | Batch 500/782 | 单Batch损失: 0.4588\n",
      "Epoch 23/40 | Batch 600/782 | 单Batch损失: 0.4711\n",
      "Epoch 23/40 | Batch 700/782 | 单Batch损失: 0.6688\n",
      "Epoch 23 完成 | 训练损失: 0.4769 | 训练准确率: 83.42% | 测试准确率: 84.67%\n",
      "Epoch 24/40 | Batch 100/782 | 单Batch损失: 0.3449\n",
      "Epoch 24/40 | Batch 200/782 | 单Batch损失: 0.5792\n",
      "Epoch 24/40 | Batch 300/782 | 单Batch损失: 0.4305\n",
      "Epoch 24/40 | Batch 400/782 | 单Batch损失: 0.3993\n",
      "Epoch 24/40 | Batch 500/782 | 单Batch损失: 0.3771\n",
      "Epoch 24/40 | Batch 600/782 | 单Batch损失: 0.4710\n",
      "Epoch 24/40 | Batch 700/782 | 单Batch损失: 0.3654\n",
      "Epoch 24 完成 | 训练损失: 0.4715 | 训练准确率: 83.58% | 测试准确率: 84.01%\n",
      "Epoch 25/40 | Batch 100/782 | 单Batch损失: 0.4161\n",
      "Epoch 25/40 | Batch 200/782 | 单Batch损失: 0.4130\n",
      "Epoch 25/40 | Batch 300/782 | 单Batch损失: 0.3507\n",
      "Epoch 25/40 | Batch 400/782 | 单Batch损失: 0.5175\n",
      "Epoch 25/40 | Batch 500/782 | 单Batch损失: 0.3962\n",
      "Epoch 25/40 | Batch 600/782 | 单Batch损失: 0.5365\n",
      "Epoch 25/40 | Batch 700/782 | 单Batch损失: 0.5413\n",
      "Epoch 25 完成 | 训练损失: 0.4591 | 训练准确率: 83.95% | 测试准确率: 84.44%\n",
      "Epoch 26/40 | Batch 100/782 | 单Batch损失: 0.4219\n",
      "Epoch 26/40 | Batch 200/782 | 单Batch损失: 0.4298\n",
      "Epoch 26/40 | Batch 300/782 | 单Batch损失: 0.3857\n",
      "Epoch 26/40 | Batch 400/782 | 单Batch损失: 0.4982\n",
      "Epoch 26/40 | Batch 500/782 | 单Batch损失: 0.5355\n",
      "Epoch 26/40 | Batch 600/782 | 单Batch损失: 0.3574\n",
      "Epoch 26/40 | Batch 700/782 | 单Batch损失: 0.3226\n",
      "Epoch 26 完成 | 训练损失: 0.4541 | 训练准确率: 83.97% | 测试准确率: 84.71%\n",
      "Epoch 27/40 | Batch 100/782 | 单Batch损失: 0.3924\n",
      "Epoch 27/40 | Batch 200/782 | 单Batch损失: 0.4315\n",
      "Epoch 27/40 | Batch 300/782 | 单Batch损失: 0.3559\n",
      "Epoch 27/40 | Batch 400/782 | 单Batch损失: 0.6344\n",
      "Epoch 27/40 | Batch 500/782 | 单Batch损失: 0.3476\n",
      "Epoch 27/40 | Batch 600/782 | 单Batch损失: 0.3715\n",
      "Epoch 27/40 | Batch 700/782 | 单Batch损失: 0.5282\n",
      "Epoch 27 完成 | 训练损失: 0.4372 | 训练准确率: 84.86% | 测试准确率: 84.43%\n",
      "Epoch 28/40 | Batch 100/782 | 单Batch损失: 0.5050\n",
      "Epoch 28/40 | Batch 200/782 | 单Batch损失: 0.4678\n",
      "Epoch 28/40 | Batch 300/782 | 单Batch损失: 0.4039\n",
      "Epoch 28/40 | Batch 400/782 | 单Batch损失: 0.4929\n",
      "Epoch 28/40 | Batch 500/782 | 单Batch损失: 0.4750\n",
      "Epoch 28/40 | Batch 600/782 | 单Batch损失: 0.5359\n",
      "Epoch 28/40 | Batch 700/782 | 单Batch损失: 0.5022\n",
      "Epoch 28 完成 | 训练损失: 0.4326 | 训练准确率: 84.84% | 测试准确率: 84.66%\n",
      "Epoch 29/40 | Batch 100/782 | 单Batch损失: 0.3526\n",
      "Epoch 29/40 | Batch 200/782 | 单Batch损失: 0.3220\n",
      "Epoch 29/40 | Batch 300/782 | 单Batch损失: 0.4290\n",
      "Epoch 29/40 | Batch 400/782 | 单Batch损失: 0.3962\n",
      "Epoch 29/40 | Batch 500/782 | 单Batch损失: 0.5649\n",
      "Epoch 29/40 | Batch 600/782 | 单Batch损失: 0.4467\n",
      "Epoch 29/40 | Batch 700/782 | 单Batch损失: 0.4557\n",
      "Epoch    29: reducing learning rate of group 0 to 5.0000e-05.\n",
      "Epoch 29 完成 | 训练损失: 0.4220 | 训练准确率: 85.19% | 测试准确率: 85.04%\n",
      "Epoch 30/40 | Batch 100/782 | 单Batch损失: 0.4535\n",
      "Epoch 30/40 | Batch 200/782 | 单Batch损失: 0.3584\n",
      "Epoch 30/40 | Batch 300/782 | 单Batch损失: 0.5184\n",
      "Epoch 30/40 | Batch 400/782 | 单Batch损失: 0.3496\n",
      "Epoch 30/40 | Batch 500/782 | 单Batch损失: 0.3999\n",
      "Epoch 30/40 | Batch 600/782 | 单Batch损失: 0.6774\n",
      "Epoch 30/40 | Batch 700/782 | 单Batch损失: 0.4407\n",
      "Epoch 30 完成 | 训练损失: 0.3837 | 训练准确率: 86.47% | 测试准确率: 85.75%\n",
      "Epoch 31/40 | Batch 100/782 | 单Batch损失: 0.3535\n",
      "Epoch 31/40 | Batch 200/782 | 单Batch损失: 0.1690\n",
      "Epoch 31/40 | Batch 300/782 | 单Batch损失: 0.2427\n",
      "Epoch 31/40 | Batch 400/782 | 单Batch损失: 0.2824\n",
      "Epoch 31/40 | Batch 500/782 | 单Batch损失: 0.3223\n",
      "Epoch 31/40 | Batch 600/782 | 单Batch损失: 0.3366\n",
      "Epoch 31/40 | Batch 700/782 | 单Batch损失: 0.3447\n",
      "Epoch 31 完成 | 训练损失: 0.3608 | 训练准确率: 87.33% | 测试准确率: 85.59%\n",
      "Epoch 32/40 | Batch 100/782 | 单Batch损失: 0.3180\n",
      "Epoch 32/40 | Batch 200/782 | 单Batch损失: 0.3460\n",
      "Epoch 32/40 | Batch 300/782 | 单Batch损失: 0.2582\n",
      "Epoch 32/40 | Batch 400/782 | 单Batch损失: 0.3221\n",
      "Epoch 32/40 | Batch 500/782 | 单Batch损失: 0.3611\n",
      "Epoch 32/40 | Batch 600/782 | 单Batch损失: 0.3356\n",
      "Epoch 32/40 | Batch 700/782 | 单Batch损失: 0.2092\n",
      "Epoch 32 完成 | 训练损失: 0.3546 | 训练准确率: 87.42% | 测试准确率: 86.22%\n",
      "Epoch 33/40 | Batch 100/782 | 单Batch损失: 0.2492\n",
      "Epoch 33/40 | Batch 200/782 | 单Batch损失: 0.6831\n",
      "Epoch 33/40 | Batch 300/782 | 单Batch损失: 0.3228\n",
      "Epoch 33/40 | Batch 400/782 | 单Batch损失: 0.3360\n",
      "Epoch 33/40 | Batch 500/782 | 单Batch损失: 0.4186\n",
      "Epoch 33/40 | Batch 600/782 | 单Batch损失: 0.4582\n",
      "Epoch 33/40 | Batch 700/782 | 单Batch损失: 0.2431\n",
      "Epoch 33 完成 | 训练损失: 0.3448 | 训练准确率: 87.80% | 测试准确率: 86.03%\n",
      "Epoch 34/40 | Batch 100/782 | 单Batch损失: 0.3151\n",
      "Epoch 34/40 | Batch 200/782 | 单Batch损失: 0.3402\n",
      "Epoch 34/40 | Batch 300/782 | 单Batch损失: 0.3575\n",
      "Epoch 34/40 | Batch 400/782 | 单Batch损失: 0.4508\n",
      "Epoch 34/40 | Batch 500/782 | 单Batch损失: 0.3518\n",
      "Epoch 34/40 | Batch 600/782 | 单Batch损失: 0.2904\n",
      "Epoch 34/40 | Batch 700/782 | 单Batch损失: 0.4845\n",
      "Epoch 34 完成 | 训练损失: 0.3363 | 训练准确率: 88.06% | 测试准确率: 86.03%\n",
      "Epoch 35/40 | Batch 100/782 | 单Batch损失: 0.3098\n",
      "Epoch 35/40 | Batch 200/782 | 单Batch损失: 0.4241\n",
      "Epoch 35/40 | Batch 300/782 | 单Batch损失: 0.2464\n",
      "Epoch 35/40 | Batch 400/782 | 单Batch损失: 0.2701\n",
      "Epoch 35/40 | Batch 500/782 | 单Batch损失: 0.4191\n",
      "Epoch 35/40 | Batch 600/782 | 单Batch损失: 0.3869\n",
      "Epoch 35/40 | Batch 700/782 | 单Batch损失: 0.3189\n",
      "Epoch 35 完成 | 训练损失: 0.3301 | 训练准确率: 88.38% | 测试准确率: 85.86%\n",
      "Epoch 36/40 | Batch 100/782 | 单Batch损失: 0.3671\n",
      "Epoch 36/40 | Batch 200/782 | 单Batch损失: 0.2216\n",
      "Epoch 36/40 | Batch 300/782 | 单Batch损失: 0.1238\n",
      "Epoch 36/40 | Batch 400/782 | 单Batch损失: 0.2974\n",
      "Epoch 36/40 | Batch 500/782 | 单Batch损失: 0.2941\n",
      "Epoch 36/40 | Batch 600/782 | 单Batch损失: 0.4725\n",
      "Epoch 36/40 | Batch 700/782 | 单Batch损失: 0.2895\n",
      "Epoch    36: reducing learning rate of group 0 to 2.5000e-05.\n",
      "Epoch 36 完成 | 训练损失: 0.3219 | 训练准确率: 88.55% | 测试准确率: 85.69%\n",
      "Epoch 37/40 | Batch 100/782 | 单Batch损失: 0.2448\n",
      "Epoch 37/40 | Batch 200/782 | 单Batch损失: 0.1732\n",
      "Epoch 37/40 | Batch 300/782 | 单Batch损失: 0.2051\n",
      "Epoch 37/40 | Batch 400/782 | 单Batch损失: 0.2676\n",
      "Epoch 37/40 | Batch 500/782 | 单Batch损失: 0.4176\n",
      "Epoch 37/40 | Batch 600/782 | 单Batch损失: 0.3213\n",
      "Epoch 37/40 | Batch 700/782 | 单Batch损失: 0.2074\n",
      "Epoch 37 完成 | 训练损失: 0.2986 | 训练准确率: 89.29% | 测试准确率: 85.93%\n",
      "Epoch 38/40 | Batch 100/782 | 单Batch损失: 0.2360\n",
      "Epoch 38/40 | Batch 200/782 | 单Batch损失: 0.1479\n",
      "Epoch 38/40 | Batch 300/782 | 单Batch损失: 0.3533\n",
      "Epoch 38/40 | Batch 400/782 | 单Batch损失: 0.5048\n",
      "Epoch 38/40 | Batch 500/782 | 单Batch损失: 0.1659\n",
      "Epoch 38/40 | Batch 600/782 | 单Batch损失: 0.3273\n",
      "Epoch 38/40 | Batch 700/782 | 单Batch损失: 0.2075\n",
      "Epoch 38 完成 | 训练损失: 0.2927 | 训练准确率: 89.52% | 测试准确率: 86.18%\n",
      "Epoch 39/40 | Batch 100/782 | 单Batch损失: 0.2367\n",
      "Epoch 39/40 | Batch 200/782 | 单Batch损失: 0.2999\n",
      "Epoch 39/40 | Batch 300/782 | 单Batch损失: 0.1458\n",
      "Epoch 39/40 | Batch 400/782 | 单Batch损失: 0.2884\n",
      "Epoch 39/40 | Batch 500/782 | 单Batch损失: 0.3936\n",
      "Epoch 39/40 | Batch 600/782 | 单Batch损失: 0.1809\n",
      "Epoch 39/40 | Batch 700/782 | 单Batch损失: 0.3922\n",
      "Epoch    39: reducing learning rate of group 0 to 1.2500e-05.\n",
      "Epoch 39 完成 | 训练损失: 0.2861 | 训练准确率: 89.81% | 测试准确率: 86.32%\n",
      "Epoch 40/40 | Batch 100/782 | 单Batch损失: 0.2916\n",
      "Epoch 40/40 | Batch 200/782 | 单Batch损失: 0.2238\n",
      "Epoch 40/40 | Batch 300/782 | 单Batch损失: 0.2087\n",
      "Epoch 40/40 | Batch 400/782 | 单Batch损失: 0.1997\n",
      "Epoch 40/40 | Batch 500/782 | 单Batch损失: 0.3312\n",
      "Epoch 40/40 | Batch 600/782 | 单Batch损失: 0.4169\n",
      "Epoch 40/40 | Batch 700/782 | 单Batch损失: 0.1733\n",
      "Epoch 40 完成 | 训练损失: 0.2713 | 训练准确率: 90.29% | 测试准确率: 86.30%\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0sAAAGGCAYAAACqrRo1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACGs0lEQVR4nO3dd3hT1RsH8G+6oVBW2RQoS5bAT0BQENlLlijIUmTJEEURRJCNgChLENmyBFFBlgzZyJ6FUqayp22h0NLSNm3u749j9s1s0pu038/z9EnuPslJ4L4557xHJUmSBCIiIiIiIjLio3QBiIiIiIiIPBGDJSIiIiIiIhkMloiIiIiIiGQwWCIiIiIiIpLBYImIiIiIiEgGgyUiIiIiIiIZDJaIiIiIiIhkMFgiIiIiIiKSwWCJiIiI3E6SJKSlpSldDCIihzBYIiKyYPr06YiNjc3QOZ4/fy67PjIyEps3b4YkSRaPffz4Mfbt22f1/NevX4efnx927Nghuz09PR2RkZGYNWsWXnvtNdy9excpKSm4efOmxT9rZdL66KOPsH37dpv7Gbp06ZLs+oiICIfOQ9aNHTsWDRs2dOk5r169irFjxyImJsap4x89eoSSJUti+fLlDh0nSRK2bdsGjUajW7dz506cO3fOqXIQETmKwRIRkYyUlBRs27YN9evXx927d3XrT548iS1btsgeM2LECNy+fVu3fOnSJZQpUwanT5822/fXX3/FZ599BrVabbEMH330ETp27Ig7d+5Y3CckJATp6ekICAgwWq/RaPDaa68hV65cqF69OiZPnowXXngB58+fx9mzZxEeHm7xz1qZtBYsWOBQkJOYmIgqVapg5cqVRuvVajXq1auHESNG2H0uss7Hx8cs4PXz84Ovry/8/Px0f76+vihatKjsOdRqNQ4cOKBbfvjwISZNmoTk5GSr19ZoNEhKSkJ6erpRGQoUKIAXX3wRCxYsMNpfkiSkp6fj+fPnsq1O+/fvxxtvvIHffvtNt27EiBFYu3at1XIQEbkKgyUiIhmBgYHYtm0bSpQogaZNmyI6OhoAcPToUYwZMwYA8Pfff6NPnz66Y3744QfExcXpllevXo3cuXOjWrVqSE1NRVRUFK5du4abN29iw4YN6NSpE+7fv4+bN2/i6tWriIyMNCrDzJkz4evri379+gEAkpOTjX5hB6ALklQqFdLS0nQ3sz4+PhgzZgx2796NKVOmoEaNGliyZAlatWqFoKAgAOJG1fBv2bJlUKlUZoGXHO0Nt70uXboEHx8ftGnTxmj9wYMHkZycjL59+9o8h0qlwuzZs+2+pqdSqVTYv3+/287v5+cHlUpltC5HjhzYs2cP0tLSdH979uzRfRZMHT58GI0aNcL58+d15wRE0GPNxYsXERwcDD8/P/j4+EClUun+tm/fjtOnTxut8/HxgZ+fH3LmzCnbOvrdd9+hbt26eOedd3TrAgMD4evra7Tf33//bfuNISJygv3/0xERZTNBQUHYuHEjevbsiZSUFN26HDlyAADi4+OxYsUKLF26FADg6+uru4lTq9VYunQp5s2bB39/f5w9exYvv/wygoKCoNFokJiYiHv37uGHH34AAF0QFB8fr7t+4cKF8e2332LGjBl49OgRXn/9dVy4cEG2rI0bNwYAtGjRQnfT2bx5cwCiNcyQj4/l38lMtyUnJ8u2Jvj5+SEtLQ1Pnjwx25Y3b17d86SkJNy/fx8HDx5ElSpV8PjxYzx+/Bh58+ZFaGgoVqxYgWLFimHPnj3Ys2eP7rhmzZqhbNmyFstp6uzZs9i/fz8++eQTu49xh/Hjx+P9999H6dKlLe5z8uRJvPDCCy6/9po1a3Djxg389ddfuH37NiZOnIj69eujcePG0Gg0ePbsmVF9PXv2zGKXy+XLl6Ndu3Z48cUXAeg/F/7+/rp90tPTkZKSYhS8VKhQAdeuXUNQUBCio6NRokQJ3ffgzJkzAIBGjRqhbdu2GDp0KFJTU3XnMW3lunjxIjZv3oxffvnF6uuOjIxE7dq18cMPPxj9eEFE5AoMloiIrMiVKxfWr1+vWzZsdTH9ddvQzz//jGLFiqFjx444c+YM3njjDVy/fh0lSpTA9OnTsWXLFqNuTpa8//776NatGwIDA7Fx40b4+PgYBTRJSUmoUqUK1qxZg9q1axvdzFqSmpoKALh8+bLR+gcPHui6T2lbJiZOnIipU6fKnufLL7/El19+abb+2bNnCA4OBgAcOnQILVq00G0rX748AODzzz/Hl19+iXXr1qFEiRJYsmSJbp/IyEisXbvW4WBp9uzZigdLEyZMQMOGDa0GS7Vq1XLLta9du4Zz587hwYMHePbsGU6fPo0yZcoAEN1K27Zta3ZM4cKFzdbdvHkTP//8M1JTU81aqORaHU+ePKl7TQEBAShTpgyWLVuGjz/+GAcPHkRwcDB8fHwQGhoKQHxvcubMiSNHjuDzzz/H9u3bUa5cObPzfvzxx5AkCbVr17b4muPi4vDWW2+hYsWKeOutt6y8O0REzmGwRERkIjIyEm+++SaCgoKgUqmwYMEC1K9fH4DoQmUrAUJiYiLGjRunG58xf/581KxZEyqVCo8fP8a6devQqVMnPHnyBH5+fsiVK5fZOZ4+fYocOXIgICAAgYGBAIBy5crhxIkT8PPzw0svvQRABCYAULRoUaMbzvT0dNSqVQs5c+bEgwcP8PjxY9SuXRstWrTAG2+8AQCoVKmSbPlTUlJ03bMCAgJQqlQp3Lx502ifvHnzYvz48UbByU8//YR3331XV14AuueG71nTpk0RGBiI77//Hrly5UJERARy5syp2160aFG7ugKSMW330K+++gq7d+/Gpk2bAACxsbH4559/LB739OlT5MmTR7c8bNgw1KpVy+hHgiNHjqBTp064d++ebl16ejqSk5NRvHhxo/Pdvn0bI0aMQKtWrVCjRg0cOnRI9rrVq1dHcnIyGjRogAMHDugCOwBYsWKFUUujnEePHqFZs2bw8/PDrl27jFo0iYhchWOWiIhMlChRAlOnTsXXX3+NCxcuGHVDS0lJMfu13dSkSZMQHx+P06dPY9SoUfj1118xd+5chIeHIywsDCdOnMCkSZNQtGhRtG/fXvYc3bt3R2BgIFQqle4Xee36sWPH2nwNvr6+WLRoEX744QcUL14cFStWxIIFC9CrVy/873//041/MhyzlJ6ejqSkJKOxSNZazywxbPmydHxMTAymTp2KSZMmGQVKgOjCaBhwWfP+++9DpVKhV69euHXrlm4szPjx4432mz9/PsqVK4fg4GDUr1/fLDlFw4YNMX78eFy4cAFt27Y1u/H+999/0aVLFxQoUAD58+dH586ddZkS9+/fr7suILqZqVQqi61LlsYsJSQkoF+/fsibNy/y5cuHDz74QBcMA0Dp0qWxfPlyTJ06FUWKFEG+fPnw0UcfWQzeJUnC48ePMXToUKsJPebNm6c7ZtOmTdi4cSO+//57FClSRPcHAMHBwUbrihcvjrJlyxqNe3ry5AlatmyJIkWKYNmyZQBEF1PDsXbaMVOlSpXC3r17kZaWhsaNGyMhIQGAyI744YcfYsCAAbKvS1sfDRs2xPPnz7F3714UKlTI4r5ERBnBYImIyIT2ZljbbcmwlUM7RsOaNm3aoFOnTsiZMyfWrl2L4cOHIzw8HKmpqfjwww/x7rvv4smTJ5g0aZJu/JOp77//Hn///TfGjx9vdDM6dOhQbNu2zawLnZzatWujZMmSOHHiBHLlyoWjR48iNDQUn3zyCYKCgswG4Gu7R23cuFF3DluBoRy5MVHPnj3T/aWnp6Nw4cLYtGkTqlSpgrZt2xrdTKemplpMPGBq/PjxOHnyJMaNG4eiRYvi5MmTOHnyJD744APdPitWrMCQIUMwePBgbNu2DaGhoWjcuDEePXpkdK5r166hUaNGKFmyJL766iujbT169MDZs2fx008/4eeff0ZUVJQug1/NmjV11wVEpkBrWRPlSJKEdu3aYceOHVi0aBEWLlyI7du3o0OHDkb7zZ49G5s2bcLSpUvx+eef4/vvv8fWrVuN9nn69CkuX76MChUq4KeffkKOHDnQvXt3s4QekiShZs2aRu918+bNceLECfzvf/8zOmdcXJxsC6gkSXj+/Lkug2Lu3LnRs2dPbNy4UdcVMzk5WTfmT7usTalfpkwZbN26FZMnT0bu3LkBAIsWLUK9evUwcuRIi+/XkiVLkCdPHhw6dMhiRj8iIpeQiIjIIgDSwYMHdcvDhw+X2rVrJ0mSJEVEREi+vr66bXny5JHOnz+vW96yZYtUpUoVKSUlRZIkSfrrr7+kHDlySPv27ZNu3LghjRo1SmrcuLF048YN6cqVK9KtW7fMrj937lypVKlSuuWnT59KQUFB0ogRIyRJkqSEhAQJgLRv3z7Z8k+cOFEKCgqSGjduLFWuXFkaP3689PjxY+nBgwfS48ePpS1btki+vr5SXFyc9OjRI+nevXtSYmKi0fFhYWFSXFyc0V9ISIg0ZcoUo3ULFy6UTP9bOXjwoATA7G/cuHGSJEnS3bt3pYCAAGnt2rW6YwIDA6UTJ07I1sWsWbNkX+eyZcuM3idDpUuXlj7++GPd8uPHjyVfX1/pxx9/1K17/fXXJQDShg0bZM/x448/SufOndMtf/jhh1KlSpVky2ipLqzts3fvXgmAtGfPHrN1+/fvlyRJkkqVKiUVLVpUSkhI0O1TuXJl6auvvpIkSZK+/PJLqVSpUhIAqWjRotK6desktVot9e/fX+revbskSZK0ceNGqVixYtK1a9ckSZKkmjVrGr2nLVq0kK0vW3/Lli0zej2xsbFSdHS09PjxY+nmzZtSZGSk7nNy/vx56fr167pltVptdKxGo5GePXsm3blzRwIg3bhxQ7d+7ty5UkBAgNS8eXMpOTnZ6vtMROQKHLNEROSAS5cuoUKFCjb3u3PnDgYOHIg//vgDAQEB0Gg02LVrF1JTU9G+fXuoVCqkpKQgLS0NNWrUQEpKClq1aoXff//d6nlDQkKwcuVKtGrVymYZ/v33X3z//ffo27cvLl26hKFDh2LEiBEYPnw48uXLBwC61gJL4z00Gg3u3Lmj29/QqFGjMGrUKLP16enpZt3vDCczNRyIX7x4cbzzzjv4+uuv8c4770CSJKMxUxmVkJCAmzdvYs6cOZgzZ47RNtN0061atTJrydHq2LEjli1bhtGjR+PYsWN49OgRwsLCXFJGADh16hR8fX3RoEED3boGDRrA398fJ0+exOuvvw5AdDs0bOEpWLCgrlUnKSkJb7/9NuLj43H16lXZhAeJiYl49OgRSpUqJVuOH3/8EWq1GgEBAUativXq1cONGzfQoUMHXQZHQHw+kpOTjbqKAkD//v2NxjxZUrFiRZw5c8ao66dKpUJwcLBRGv6IiAh8+umnOH36NHLnzo3atWvb3VWTiCgj2A2PiMgOf//9NzQaDc6cOYOXX37Z6r4PHjxA06ZNkSdPHkyZMgVVq1bFyy+/jM8//xzx8fF49OiRrhteixYt8OTJE8THx9sMlLQ6deqku2HWTuRp2l1Oo9GgT58+6Nixoy6rXOfOndG0aVOkpaXh2LFjiIqK0k2ie/nyZVy4cMFsLI9arUbZsmXNum/lyZMHs2bNMlq3evVq+Pr6GnW50goNDdX9mWbs69u3LyIjI3Hx4kVd9yzTcUzOkv4bz/PVV18hIiLC6G/w4MFG+1qq14SEBPzvf//D8uXL0bBhQ/z666+YP3++S8pnWk5b26xlCJwxYwamT5+OkiVLGq03rI+YmBhUqFDBKJg1nAy2WLFiKFWqFIoWLaobm7Rnzx48fPgQmzZtwtatW3Hy5EndtmLFiqFMmTIICQkxuuZPP/2E1NRUjBgxAlWqVMGTJ0+MPiuffPIJcufOjXXr1lnsiqp1584d1KtXD8+ePcOJEydkM+cREbkLgyUiIhs2bNiAJk2aYM+ePYiOjkazZs0AwGyCWK38+fMjNDQUVatWRZ06dTB37lz88ccfyJUrF6KiolCrVi2jlpaffvoJjRo1MrppteXJkyc4ePCgbhC96XiSzZs3Y+/evboMaYAYT7J27VrEx8fjlVdeQZ06dTBo0CCkp6ejbt26qFu3rlHLBiCCDGuZ1Ax169YNaWlpDgc6r732Gs6cOYPKlSvrEhqY3nzbEhQUJPv+hYSEoGTJknj06BFq1Kih+1uyZInFLG2m9u7dixs3bmDDhg0YOnQoGjZsiOvXr8vuGxgY6FA9atWuXRvp6ek4ePCgbt2hQ4egVquNUmdbS7hhaXxZyZIldQHG/v37jc736quvmmWzM3T69GkMHDgQ48ePR9u2bTF+/Hh06tQJy5cvt/p6goKC4O/vj8mTJ6Ns2bJo27atbozY5MmTsWDBAvz++++oUqWK1fMAQFhYGA4dOoTjx49bzOCYnJysa2EjInIldsMjIrJA28oxa9Ys/PTTT1iwYAE6dOiA/PnzA4DZzZn2V/PAwEAcPnwYgOgatWfPHsycORNffvklunTpglq1aqFAgQK645o0aYKPP/4YEyZMwKRJk3TrY2NjsXnzZsTFxeHgwYN47bXXdNv8/PzQokULPH/+HPXr10f16tWNytKhQwfs3r0bxYoVM2u1KF68ONLS0uDr64v9+/ejadOmspPLupJh6nHTSW5VKpWu/NquV44GSzVr1sS///6LpUuXomLFijh8+DCGDRsGHx8fjBs3DoMGDULRokVRt25dbNiwAQsXLsS7775r17m1XcyWL1+Oxo0bY/369Zg3b55sYoE6depg0aJFyJkzJ+7evYvixYujXr16Nq/RsGFDNGzYEO+//z6mT58OQKTwbtKkCRo2bGj/GyFjwoQJAIBdu3Zhy5Yt2L9/P3r27Inq1atjxowZFufmWrVqFQYPHozOnTtj+PDhAICRI0fCz88PvXv3xtKlSzFx4kQ0atTI4rV9fX3x66+/onPnzqhZsyZq1qyJAwcOYOvWrbqJlC3R/hghSZIuVb4lx44dQ79+/bBu3Tqz7wIRUUawZYmIyIKjR48CAAYOHAh/f39s2LABn3/+uW57sWLFMGXKFN1yamoqUlNTcfnyZUyZMgXNmzdHgQIF8NlnnyE5ORkdOnRAqVKlsGrVKvj4+Ogm/SxatChmz56NqVOn4syZMwBEa0a1atV0LVrjxo1DrVq1MGbMGPz22284c+YM5s2bh61bt2LOnDk4ffo09u3bh40bN+paZ1599VUAxqmbY2NjERkZiatXr+Ly5ctG3fAuX76MyMhInD171uZ7o007bs9+AIxSVR8+fNhiq9ylS5cQGBjo8HiU8uXLY+HChbpJYVeuXKnb1rt3b0yfPh0LFixA8+bNsX//fmzcuBF16tSx69z16tXDpEmTsHDhQrRq1QpXr17FjBkz8ODBA7MWpsWLF+PBgwdo3LgxBg8ejPj4eLuuoVKpsHnzZjRv3hz9+vVDv3790KJFC6PMhLakpqYiMTERN27cMAqAUlJS8N1336Ft27b47LPPULduXVSvXh1Tp05FlSpVzLLp/fXXX2jdujXee+899O3bFwsXLjTaPnz4cOzcuVP3OsuXL2+xpSk9PR0REREoXrw47ty5g23btqFcuXKIiYkxal2Vo/2MmH5WAgMDceLECVy/fh03b97EzZs3sXLlSly/fp2Z8YjI9TI5oQQRkdeIioqSGjZsKD1//lxasWKFNHToUKv7+/j4SEeOHJF++uknKSQkRPrwww+lyMhISZIkafTo0VKNGjWkp0+fSpcvX5Z69+4thYWFSQMGDJAkSWT6evXVV6Xvv/9e0mg0Ur9+/aSBAwcanX/Dhg1Sx44dpbJly0ohISGSn5+fWVayF1980axcU6dOlerXry9Jksga5+vrK4WEhEgFChQw+8uTJ49UtGhRm+9NUFCQNG3aNJv77dq1yyxDXpMmTXTZ/CRJkm7duiUNHTpU6tWrl1SgQAGpVatWNs9L5q5evar7HEybNk1KSUmRevbsKYWGhkrBwcHSjBkzjPZ//Pix1K1bNwmA9Mcff0iSJEljx46VAEgVK1aUdu3aZfV6SUlJ0owZM6SSJUvqshcmJiZK8+bNkz7//HOpefPmUt68eaXcuXNL77//vnT27FnpwYMH0rBhw6SCBQtKAKQiRYpIDRo0kDp37iz9+++/Rue/fPmyBECKiooyWj9v3jyzz76fn580bNiwjL6FRERmVJJkx0+DRERkt+fPnyM9Pd1oHFFSUhISEhJQuHBhpKen480330TlypXx6aefonDhwgDEQHttVjBJknRZyTJq0qRJ+OOPP3D8+HEkJyfDz8/PKPuYo7TZ6iZNmoTRo0db3ffSpUtYuHAhZs+erVu3adMmhIaG6rqnSZKEChUqIDg4GC1atMCoUaOQJ08ep8uXnW3fvh3Vq1dHsWLFAAArV67ErVu3MHDgQLOMdVp//vknmjdvDpVKhefPn2Pjxo3o3Lmz3RMSazQao7m1OnfurEvK0LRpUzRs2NAsu6E2yciePXtw9uxZVKpUyaiV1pb09HSjbrD+/v5OTaBMRGQLgyUiIiIiIiIZHLNEREREREQkg8ESERERERGRDAZLREREREREMhgsERERERERycg2k9JqNBrcv38fuXPntjjLORERERERZX2SJCEhIQHFihUzyuhpKtsES/fv30dYWJjSxSAiIiIiIg9x584dlChRwuL2bBMs5c6dG4B4Q0JCQhQti1qtxs6dO9G8eXOjWdbJO7D+vB/r0PuxDr0b68/7sQ69X3avw/j4eISFheliBEuyTbCk7XoXEhLiEcFSzpw5ERISki0/nN6O9ef9WIfej3Xo3Vh/3o916P1Yh4Kt4TlM8EBERERERCSDwRIREREREZEMBktEREREREQyGCwRERERERHJYLBEREREREQkg8ESERERERGRDAZLREREREREMhgsERERERERyWCwREREREREJIPBEhERERERkQwGS5lMowHGjfPBjh2llS4KERERERFZ4ad0AbKbS5eAc+dUiI4urHRRiIiIiIjICrYsZbL0dKVLQERERERE9mCwREREREREJIPBEhERERERkQwGS0RERERERDIYLBEREREREclgsJTJVCqlS0BERERERPZgsJTJJEn/PC1NuXIQEREREZF1DJYUdOwYm5mIiIiIiDwVg6VMZtgNLzVVuXIQEREREZF1DJYymWE3PCIiIiIi8lyKBEubNm1CmTJl4Ofnhxo1auDSpUs2j2nXrh1UKpXur2nTpplQUvdi4ERERERE5LkyPVi6du0aevXqha+//hr37t1DhQoV0LdvX5vHnTp1CufPn0dcXBzi4uKwadOmTCit6xl2w2OwRERERETkufwy+4KXLl3C119/jc6dOwMABg4ciDfeeMPqMffu3YMkSahatWpmFDHTMFgiIiIiIvJcmR4stWnTxmj5ypUrKF++vNVjTpw4gfT0dJQoUQJxcXFo27Yt5s+fj3z58rmzqG5hGCAxwQMRERERkefK9GDJUGpqKmbMmIGhQ4da3e/y5cuoXr06pk+fDh8fH/Tt2xcjR47EggULLB6TkpKClJQU3XJ8fDwAQK1WQ61Wu+YFOCEgAJAk0fvx8eN0qNVsXvI22s+Pkp8jyhjWofdjHXo31p/3Yx16v+xeh/a+bpUkKdcZbOTIkdi+fTtOnjwJf39/u4/766+/0LFjR8TGxlrcZ/z48ZgwYYLZ+jVr1iBnzpxOldcVoqNzYNGiagCA1167i9dfv6dYWYiIiIiIsqOkpCR069YNT58+RUhIiMX9FAuW9u7diw4dOuDYsWOoXLmyQ8devnwZlSpVQnJyMgIDA2X3kWtZCgsLQ2xsrNU3xN1u3QI+/tgHMTExGDgwH959l9nbvY1arcauXbvQrFkzh4J88hysQ+/HOvRurD/vxzr0ftm9DuPj4xEaGmozWFKkG96NGzfQtWtXzJs3z65A6Z133sFHH32E+vXrAwCOHj2KwoULWwyUACAwMFB2u7+/v6IfCD8/QKXSAAB8fHzh769oT0jKAKU/S5RxrEPvxzr0bqw/78c69H7ZtQ7tfc2Zfqf+/PlztGnTBu3bt8ebb76JZ8+eAQCCg4ORkJCAHDlymBX+xRdfxKeffopZs2YhNjYWI0eOxMCBAzO76C7HbHhERERERJ4r0/uA7dy5ExcvXsTixYuRO3du3d+tW7dQrVo1bN261eyYESNGoFq1amjZsiUGDhyIQYMG4csvv8zsorucRqN0CYiIiIiIyJJMb1lq3749LA2Tunnzpux6f39/LF26FEuXLnVjyTKH4UtPTlZZ3pGIiIiIiBTF7AKZzDBY2raNwRIRERERkadisERERERERCSDwRIREREREZEMBkuZzFUZ8NLSgD17gOho15yPiEgOs3YSEVF2xmDJS23ZAsyeDfTpo3RJiCir+vVXoHdv4NEjpUtCRESkDAZLmaxQIdecJzLSNechIrJk1SogNhZYs0bpkhARESmDwVImy51b6RIQETmGXfGIiCi7YrBEREREREQkg8GSB0lMBDQapUtBREREREQAgyWP8eAB0KUL8MUX9u2v4ny2RERERERuxWDJQ+zbJx4vXVK2HEREREREJDBY8hAcQE1ERERE5FkYLBEREREREclgsERERERERCSDwZIHSkxUugRERERERMRgyUMYjln6+GPlyqE0SQKmTwfWr1e6JERERESU3TFYUpg2SDIMlqKjbR+XkdThrkgmce0a8OxZxs9j6swZ4MABYPlyZgYkIiIiImUxWFLYTz85d5yzAU9kJNCjB3DkiHPHA0BUFPDJJ0CfPs6fw5KUFP3zsWNdf34iIiIiInsxWFLYr78Cd+5k3vVGjwbi44GpU50/x4kT4jEpyTVlsiQtzb3nJyIiIiKyxk/pAhAwaJDjxzjbDc/V8zklJwNBQcbroqOB7duBtm2B/Pldez0iIiIioszCliXKkE6dgL//Nl43ahSwbh0wZYoyZSIiIiIicgUGS5Rhv/5qvPzvv+LxypXMLwsRERERkaswWPJSGcmGR0REREREtjFYIp27dzM32YQcwzFVrh5fRURERETkCAZLWUBqKhAba7zO0UBDrQYGDhTJJlJTzbf//jvw5Zfy24iIiIiIsiIGS14oLU3MdaT1wQdAr176VqHkZGDAAGDePPvPmZysf/7ggXkL07JlYo6mnTsdK+ujR+Jx1SpgwgRAo7G+v1z3wuvXgZMnHbsuEREREVFGMVjyUL//bnnbvHlAYqJ+WRuQaAOKgweB+/eBHTucu/bgwaKF6d49822Otixdvy4ef/0VOHUKiIgw38fwtcgZMgSYOBG4dcuxaxMRERERZQSDJQ+1bJnlbbt3O3dORyd5vXzZ/n0lCViyBPjzT+v7jR8PxMXpl/ftA7p0AX75xfY17t+3vzxERERERBnFSWmzEEkCfvrJuMuaJAGTJwO5c7s3lXdUFLBpk/l6uW51P/8MvPsu4OMDzJkj1v30E/DOO9avwYQPRERERJSZGCxlIXfuAHv2GK+LigKOH3f/tZ89k18/cSKwebPxuqQkoFs38dzPyicwPR24eNE15SMiIiIichS74XmwCRP0rSkaDfD4sfX9TQMlABg1yvL+kgRcuADEx1ve7sh6e/c1zNxnmvDBdP8RI4z33bYNuHlTvy4tzTwTIBERERGRK7BlSQEvvSTZlXzh1CmRZKFECRE4nTnj2sloT5wAvvoKCA4GFi823y5JIvlCcLB+ndxYqn/+ARo3tnwd0wAoIUH/3FZ2PEPTpumfb9kiHocPF9cfMQLIlQuoUcP+8xERERERWcOWJQX4+9u/rzbQOHPGeNkVTpwQj4mJQHS0+fa5c0XyhfPnrZ8nNtZy6xQA/Pab8fLt25b3dTRF+D//iMdp04AxY4CzZx07noiIiIjIEgZLCggIsH/fv/92XzkMPXlivk4bmK1da/t4a10EV62yrwyPH8t3JbRELuW44fxTREREREQZwWBJASVK2N88NGuW+7LA2TvB7NWr7rm+qcGD7d83JUW0eplyZTdFIiIiIsreGCx5gXbt3H8Na3M3JSfbPt7WxLL2MBzLZMuDBxm/HhERERGRNQyWCABw6FDGjpebY0kJO3eKFOpERERERBnFYImylMePgUGDlC4FEREREWUFDJbIK337rdIlICIiIqKsjsESeSVr6ccB4NKlzCkHEREREWVdDJYoS8qslOtERERElHUxWFKAu1KBExERERGR6zBYoiyJASkRERERZRSDJcqSli9XugRERERE5O0UC5Y2bdqEMmXKwM/PDzVq1MAlO0bkHzhwAJUqVUJoaChmzpyZCaV0D5VK6RJkfWlpSpeAiIiIiLydIsHStWvX0KtXL3z99de4d+8eKlSogL59+1o9JiYmBu3atUPXrl1x9OhRrF69Gvv27cukErsWu4gREREREXk+RYKlS5cu4euvv0bnzp1RuHBhDBw4EBEREVaPWb16NYoVK4YxY8agfPnyGDt2LJYuXZpJJSYiIiIiouzGT4mLtmnTxmj5ypUrKF++vNVjzp07h0aNGkH1Xx+2l19+GV988YXF/VNSUpCSkqJbjo+PBwCo1Wqo1Wpni+4S6ekaAIAkSdBoNIqWJSv7++90lC7t+vNqPz9Kf47IeaxD+2g0vgCA9HQJarVn/VvFOvRurD/vxzr0ftm9Du193YoES4ZSU1MxY8YMDB061Op+8fHxqFy5sm45JCQE9+/ft7j/1KlTMWHCBLP1O3fuRM6cOZ0vsAvcuFEIQDhiYmIULUdWt2XLZZQt+9Rt59+1a5fbzk2Zg3VoXXR0HQDAxYsx2LbtusKlkcc69G6sP+/HOvR+2bUOk5KS7NpP8WBp3LhxCA4Otjlmyc/PD4GBgbrloKAgqy9y5MiRRgFYfHw8wsLC0Lx5c4SEhGS84BnQqJEa27bFo2DBgrqWMnK9UqVC0bq16weIqdVq7Nq1C82aNYO/v7/Lz0/uxzq0z6JFomWpcuWCaN26osKlMcY69G6sP+/HOvR+2b0Otb3ObFE0WNq7dy/mzZuHY8eO2ayk/PnzG7XEJCQkICAgwOL+gYGBRsGVlr+/v8d8IFQqFXx8mL3dXW7e9IE7q9qTPkvkHNahddp/nnx9AX9/X2ULYwHr0Lux/rwf69D7Zdc6tPc1K3anfuPGDXTt2hXz5s0z6l5nSe3atXH06FHdckREBIoXL+7OIpKXy6ZdcImIiIjIRRQJlp4/f442bdqgffv2ePPNN/Hs2TM8e/YMkiQhPj5edsBVu3btcPjwYezevRtqtRrffPMNWrRooUDpyVscPqx0CYiIiIjImykSLO3cuRMXL17E4sWLkTt3bt3frVu3UK1aNWzdutXsmNDQUMyaNQutW7dG4cKFceXKFYwePVqB0hMRERERUXagyJil9u3bQ7IwM+vNmzctHjdgwAC0aNECly9fxmuvvYZcuXK5qYRERERERJTdKZ4Nz1Hh4eEIDw9XuhhERERERJTFMRWbQmrW/FfpIhARERERkRUMlhRSsKB9E2FRxly+rHQJiIiIiMhbMVhSCKdXyhzDhytdAiIiIiLyVrxlV4hKJZ/ggoiyt19/BZYvV7oUREREBHhhgoesQqVSugRE5GkkCVi1Sjxv1QooXFjZ8hAREWV3bFlSSOnS8UoXgYg8jOGMCqmpypWDiIiIBAZLCsmbN0XpIhARERERkRUMloiIiIiIiGQwWKIs7/RppUtARERERN6IwRJleUuXKl0CIiIiIvJGDJYUFBKidAmIiIiIiMgSBksKqlqVcy1lhjt3xNw1RERERESOYLBE2YJ27hoiIiIiInsxWCIiIiIiIpLBYElBDRuyGx4RERERkadisKSg2rUlzJ2rdCmIiIiIiEgOgyUFqVRA6dJKl4KIiIiIiOQwWCIiIiIiIpLBYInIjeLigNu3lS4FeQuVSukSEBERkSE/pQtAlJW99554XLwYKFJE2bIQERERkWPYskSUCf75R+kSEBEREZGjGCx5gNBQpUtARERERESmGCx5gClTlC4BERERERGZYrDkAYoWVboE2UN6OhAfr3QpiIiIiMhbMFiibGPoUKB7d+DePaVLQkRERETegMESZRvXr4vHffuULQcREREReQcGS5Tt/PKL0iUgIiIiIm/AYImypSNHlC4BEREREXk6BkuULU2dqnQJiIiIiMjTMViibOvxY2DLFiAxUemSEBEREZEn8lO6ACSvdWvg8mUgOBg4f17p0mRNo0aJzHgXLwIjRihdGiIiIiLyNAyWPIRKBUiSeD5pElCjhni+fTuDJXfRphA/edK+/dVqwN/ffeUhIiIiIs/CbngeYtEiYMAAYP16faAEAC1aiPmB8uUzP6Z69UwrXrZ37hzQsSPw229Kl4SIiIiIMguDJQ9RpAjwxhtAQIDxeh8foFEjoFAh82PKlMnYNYcPz9jxAFCsWMbPodWunevO5Wrffy8eV65UthyUtWlbl4mIiMgzMFjyYiqV/fvWq2e+rkED4OWXgVdekT/mm29cWwZDhq1ncgIDnTsvEREREZGrMFjyYqaByv/+J79fqVJAv37y28aMEYkOTLVvD1SqlLHyWRMebn171aruu7aplJTMuxYREREReQ8GS14oVy7xWL++ffuXLWu7BWj6dOPl3r0dL5c1H38M5M+vX/b3F0GcoaAg6+dwZ/B27pz7zk1ERERE3onBkheaNw9YuhQoVw5Ys8Y153zhBZGuXMvHiU+GpeCtWzegWTPjgK1OHTFGy9AbbwBt24pgsH178/OEhwOdOhmvsxVg2Wv0aODKFcvbne1uSERERETei8GSFwoI0Cd8yJ3b9v6uvtEfOlT/3HAslKW5igoXNi9HhQrmg9mDgoAPPgBWr5bP/gcA771nvLxqlX1ltsfVq647FxERERF5PwZLXsKe+X0ymknLnuM7dzYeGxUaarx96lQgJMQ4oNLq2FE81q1r/Rr2tmp16WLcslS8uMgcSERERETkCgyWvMSnn+qfBwcrVw5Tpq1WVauKliHDoKVoUfHYpg0wd67lFqgcOTJeHrmsf55k8WJg8GAmlSAiIiLyBgyWvEShQsCWLeLPWre6d95x/hr2dtfTJpgA9GnHw8LM9/v6a5HYQZuYQaUCSpcG/PxsXz9PHvvKooSnT4GkJAsvwobNm4Fbt4C//nJxoYiIiIjI5RQLlmJjYxEeHo6bN2/atX+7du2gUql0f02bNnVvAb1QhQpAiRLy21w52aWfH7B2rfjLkwf47TfRYmSqShWR2MEZ+fKJpAtffWV5nyJFnDt3RvXs6YuZM2siLc35c2g0risPEREREbmHcz+PZ1BsbCzatGljd6AEAKdOncL58+dR4r9owN+eQTzZxLx5wIkTQLt2wNGjzp/HkYDKsCugsxnpDCemrVXLfHudOvLXnDoViIpy/fgka13j5Frdnj93TddBIiIiIvJMdrcsLViwABobP4enpqaiXLlyNs/VpUsXdOvWzd5L4969e5AkCVWrVkXevHmRN29eBHvSwB2FlSwJvP22yJLn7hTXrjx/sWL652+9ZXm/IUNEYKXdp2pVkdzBNBFE+fIZK098fMaOd4QrW/qIiMh9Fi2S7z1BRNmD3S1LU6ZMQb9+/fD7778jPj4ePjIpyyRJQpodfZMWL16M8PBwDBkyxK5rnzhxAunp6ShRogTi4uLQtm1bzJ8/H/ks5ZcmAKK7XFoa8NJLxuurVgW8qRdj06bWy/vDD8D+/cCbbwIXL2ZasRzCeZqIiLxPaqoYKwwAXbuaZ4AloqzP7mDJz88Pvr6+mDp1KmrVqoW1a9eiS5cu+O2339CpUyfdo1wQZSo8PNyhQl6+fBnVq1fH9OnT4ePjg759+2LkyJFYsGCBxWNSUlKQYtCvKv6/ZgO1Wg21Wu3Q9V1Ne313lCMtTQWNRtTBggXpuHlTpPp+9AjQaHwBACNGpCM4GDC9fHq6DzQa1X9lSwcAdOigQnS0CocOqf47vwZqteuaRbRlUqvTzcpjryJFREsTYPz6HZWebvm1aTT690b6r1lIfJasn1P/+sS5tcuufh/JMe78DmaERuOa74TryiPKkp4uQa32rIF2nlqHZB9vqb+UFP33IDlZ+e+kJ/GWOiTLsnsd2vu67QqWkpOTdc9VKhXmz5+P3bt3Y/78+Th06JDRo6OBkD1GjhyJkSNH6pa//fZbdOzY0WqwNHXqVEyYMMFs/c6dO5EzZ06Xl9EZu3btcvk5L1zIj+ho0R/t2LHjAIDt24H4+ABER4sJknbuPIXAwHSzY0NCAvHoUXXUqBGNbdtuAhC/ooWGAr//LgYQnTt3D/ny3XVZeaOjxXkjIs7h9u1kG3vbdvVqXkRHv+DUsZGRD7Bt223ZbbdvV8fjx8aDs/bt24ccOay3pGpf39Gjf+Pp08e65VOnriM9PcapcpLruOM7mBEajf4zs3fvORQsmPHvREZoy3LxYgy2bbuuaFks8bQ6JMd4ev2lpvogOro2AGDPnrPIm5fzPpjy9Dok27JrHSYlJdm1n81gKTExEQULFkRaWhpeffVV/P333wBE0CT3mBkKFSqER48eISUlBYGBgbL7jBw5EkMNZkaNj49HWFgYmjdvjpCQkMwqqiy1Wo1du3ahWbNmLk9UkSePCocPi5aV1q1b69bHxgJr14pfx1q0aAFL8WLnzoCfXyiAykbrFy0Sx9aoEYrWrau5rLxFigCPH6vQtGljl5yvYEEV9u93rmWpYsWCqFGjqtFYKq0//vCBn5++ZSkmJgYNGzZCgQLy9ZeWBkREqFCokCjLK6+Eol49Sfc+1qoVihYt2LKkFHd+BzNCowGWLBGfkUaNGqNkSWXLo/28Vq5cEK1bV1S2MCY8tQ7JPt5Sf8nJwPLl4nvQpEkTFC6scIE8iLfUIVmW3esw3s7B6jaDpYCAAGzevBnvvfcePvzwQ4wePTrDhXPUO++8g48++gj169cHABw9ehSFCxe2GCgBQGBgoOx2f39/j/lAuKMsfn76xAf+/vqgwd9fvz4gwAeWLmtpvfZYPz/LxzrDNONdRhm+Tkft2AHs2OGLyZOBaibxoK+v/rzaRCfW6m/NGmDdOvP3zV3vIznHk/49AESwZPj9Vbpo2rL4+gL+/r7KFsYCT6tDcoyn1196umd9Jz2Rp9ch2ZZd69De12zzttLf3x9NmzZFUFAQunfvjtDQUCxatAjx8fFYtGgR4uLijB4z0sIUHx8v23/wxRdfxKeffopDhw5h48aNGDlyJAYOHOj0dbIjw+SB2fD74JAvvxSBU0bs2eOashARERGRcuxO8JCWlgaNRoPmzZvj8OHDaNWqFY4ePYqmTZsaPUoZyIlcrVo1zJ49Gx06dDBaP2LECNy4cQMtW7ZE7ty5MWjQIIwaNcrp62RllgKhHDmAb74Rv5D5KTK7VuZwtlXJ1Lx5QMuW4lfF+/cznup72jQGqURERETexq7b5i1btmDixIkAgMmTJ1vcLy0tDWFhYXZf3DSwsjRJrb+/P5YuXYqlS5fafe7sqmZNkRq8bFnzbZUqZX55Mlv16kCFCsDVq64539SpwPHjrjnXV1+55jxERJQ5DDvLcH48ouzJZrAUFxeHnj17onDhwkhKSkKRIkUs7puamooBAwa4tIDkGD8/cYPvLh6SSNAiPz9gxgygbVvXnM9VgRKRozg3FxERkfJsBkv58uXDgwcPsGnTJkyePBlRUVEoXLgwatWqZdYylJ6enm1ztWd1H34IHDsGGCTYy/JOnrS+nb8yEtknLU0kiWAASERE3saubniBgYHo3LkzOnfujKVLl2LYsGHImzcvFixY4DFzFpF7tWwp/rKT/3qeOoU3hUTC8+dAz55A+fKAlV7cREREHsnh4fB9+vTB2bNnUbNmTQZKRBaw1YlIiIgQAVNkpNIlISIicpxTucNKlSqFIUOGuLosRF6FrUdEREREWZvTiZbT0tLQt29fo3Xffvstli1bluFCERERERERKc2hYCklJQU9e/YEAPj6+mLt2rVG25csWYILFy64rnRERERECmHqcCJyKFjy9fXFpk2bAAAqlQo5cuTQbduwYQMePHiAYcOGubaERB7K2n+c7KJHRERE5P0cCpb8/Pzg7++vW1b9d0f45MkTDB8+HJMmTbI6DxNRZmHMTkREREQZ5fCYJZXJT+axsbF46623UKdOHSZ9II/x+uvKXp/dNcgZ/NwQERF5FrvmWVqxYgUCAwORI0cOpKamYvfu3ciVKxeePXuGqlWromvXrvjmm2/cXVYij7J+vQovvADUrAnkzq1fHxMDxMUpVy7KGhg4ERERKc+uYGnDhg1ISkqCj48Pnj9/jokTJ+LRo0dITk5Gvnz50KJFC6PueUTZwebNPvDxAUJDAcMkkCtXKlcmIiIiInIdu4KljRs36p4XLFgQf/31FwAgNDQUkydPRv/+/fHee+9h0qRJbikkkSeLjTVeTk1VphxERERE5Fp2j1l6+PAhAOMxSz4+Pnj//fdx9OhRrF+/HlOmTHF9CYm8QEqKeExOBo4cUbYs7paczG6GRERElD3Y1bIEAE2aNEHhwoWh0WjMthUrVgybN2/GSy+9hMaNG6Nu3bouLSSRp3v7baB4ceDevcy97pMnQN68mXvNHj1EcLhiBZA/f+Zem4iIiCgz2d2ydPr0afTq1QuhoaFo1qwZ7t27h7S0NN32cuXK4fPPP8fw4cPdUlAiT5fZgdKWLcC77wImc0O7nbYV7dKlzL0uERERUWazO1gKCgrCu+++i6ioKLz00kvYs2cPnj17ZrRP//798fDhQzx+/NjlBSXKalauBH75xfnjFy0Sj6tXu6Y8RERERGTM7m54ugP8/DBt2jQAQP369Y22hYaGYu/evcjPvjlEVsXEAL/9Jp6/+iqwapXoylehgrLlIiIiIiI9h4MlAJg/fz58fHygUqmQnp6OgIAA9OnTB3PmzMH69et12fKISJ5hxrzJk0UXvqNHgc2bAZN5n4mIiIhIIXYFS8HBwQgKCoJarcbhw4cxatQodOjQQbe9YMGCePjwISZOnIhdu3a5q6xEWdKDB/rna9cCXbsqVxZHMKgje3ByXSIi8mZ2BUtlypTB+fPn0bVrV2g0GqhUKiwznIUTQJ8+fdC7d2+89NJLbikoUVZlmGByzRrzYEmSzAMTjlMiIiIicj+7giXt3EqGcywlJiaiT58+qFGjBqpXr44PPvgA5cqVc08pibIYe39tT0gABg8G6tcH+vXTr8/sDHhERERE2ZHd2fAAQDK4w0tNTUWFChUQExOD6dOn4+2338Yl5hImssvevfbt98cfwOPHYiwTkTdid00iIvJmdrUsJSYmYu/evYiOjtaty5cvHyZOnKhb3rZtG9q3b4/jx4+zhYnIhoQEpUtg25kzgJ8fUK2a0iUhIiIiUoZdwVLhwoUxefJkJCcnI2fOnJAkCY0bN9Ztz5UrFzZv3oxBgwZh5MiR+E2bE5mIvFJCAjBunHi+YYMImoiIiIiyG7tugY4cOWK0vGbNGqhUKqhUKmg0Gl33vEGDBqFUqVKIi4tDvnz5XF9aomzgzh0gLEzZMhjON22YgIK8Q2oqsG0b8PLLQLFiSpeGiIjIe9k9Zkmj0SAwMBAA8Nprr2HkyJFo3LgxWrVqhdatWwMAihYtit27dzNQIo/w39zJXue77+TXX7gAqNWZWxaAqZ+90erVwNKlQP/+SpeEyLtxzB0R2dWyNHToUAQFBQEARo0aBQCIi4vD+++/j1KlSun2CwoKQo8ePdxQTCLHVa4MtGkjkiR4E8MJaw198QXQsCHw2WfuL8PFi7b3UeImIioKyJULKF0686/tTeypPyJyDH84Isqe7GpZCgoKQmBgIHx9fREYGIjAwEA0bNgQu3bt0i0HBgbi+PHjGDlypLvLTGQ3b/5VMDYWuHLFeN3+/fL7RkXpn586BXz0EXD9ulj+91/g11+Nu9bZMnu2/rmlGwSVCjh0CBg5UmTsc7foaHGtjz5y/7WIiIiIADtblqZMmQIA+OabbzDuv1HfCQkJ+Pnnn9G5c2dUqlQJALB9+3azyWqJyDHa4KRXL/uPGTkS2LJFHDthglg3aRKwZAnQt69YvnEDGDHCtWXVdnVcvNj15zb18KF7z09ERERkyu4cV5IkGQVCuXPnxsqVKxESEqJb16pVK7Rq1cq1JSQiuy1dqn+elAR06KBfPn/efdd1pNWK3M+bW1SJiIg8id3BkkqlQufOnY3WvfPOOy4vEBE5b9Mm/fOkJPdey/CG3NV9+ZOSgBw5jK/BAICIiIgym93Z8Igo82jHG2VH164B77wDfPON8XoGS0SkJP4bRJQ9MViiLM0b/3N7+hQYMsTy9shI+fWrV1s/r73vxfPnxsuGrUaubEGKjQV27tRn/0tOBo4dA375RSwfOuS6a2U3Sn/uV6wAFi5UtgxERESuYHc3PCLKHHFx1rd/+aX8+rVr7b/GunVi8ttPPjG/sf7qK8vH/fuv/vmFC/rn584Bly4B/+V6scuQIUB8PHDvnkhm8c03wMmT9h9PniktTXy+AKBjR2XLQkRElFFsWSLKhlasAPbuNQ54tCy1XAFAerr++YYNxtvGjrV83IMHoqXIsGUqPl48nj4tHm0FSkq3lngTJd8rwzpOS1OuHESuxnmWiLInBktE2YjpfEgpKbaPsbc7nFptedsHH4g040eP2ncuT/HsmRhD5W08KbBcs0bpEhARETmPwRJRNvHkCdCzp2Pd9QBgzhz9c2s34enptn95vXTJsWsbUiIA6NNHdFU0nPSXHHPrltIlICIich6DJcrSPOkXdk9hKRGEJAEzZlg+TqMBVq2yfu5Fi5wvlyfSpl8/cSJzrsduPkRERJ6FwRJlG4GBSpfAs92/D+zfL79NkoB9+2x3yfvjD5cXK0uRJODKFfu6PxKR8vgDBhExWKJsI0cOpUvgmVJTgeho4+QNprp1A3bvdl8ZrF1bKyu0Em7fDgwbBowZY3tfb71Jc1c9paSIFj4GmkRElJkYLBFlcwMHirE5N25Y3ufZM/vH7WjnTbLXrVtAhw6OHeOsxYuB8eNdH4hoNMD8+aL1zZo//xSPGRm7ZY+sEFiamj0bmDTJeAwdERGRuzFYomwjK95AukJ0tHg8csQ159OO88noPu6webNIVS6XMj0jjhwBtm0DZs507XlJT9sF9K+/lC0HZV/e2tpLRBnDYImyNAZI1v39t/uvcfOm+bp33nH8PK6sS3u6/TlCO2eUp/CUeZaIiIi8nWLBUmxsLMLDw3FT7k5KxoEDB1CpUiWEhoZiJn++JScwcDJnmBnPVTe5Fy+KxydPgM8+Az76yPlzRUUBCQlAbGzGy5WYqH+e0dfKgEC8nz/8oK9vOXyfiIjI2ykSLMXGxqJNmzZ2B0oxMTFo164dunbtiqNHj2L16tXYZ2twABEYIDni6VPXnGfqVBHgrFwJXL1qvG3jRmDHDvvPNXKkSC7Rq5c4p7Pu3AG6dHH+eEMpKWKcV3YfO7NypUhYMWKE8Xp+54iIKCtRJFjq0qULunXrZvf+q1evRrFixTBmzBiUL18eY8eOxdKlS91YQqLsx1oLgaOePAGeP5ffNm+ec+e8e1f/PCXFsVaL7dudu6acI0eAe/eAXbtcd05Xy4yA5f79zClHWpr4PBERESnBT4mLLl68GOHh4RgyZIhd+587dw6NGjWC6r//eV9++WV88cUXVo9JSUlBikGO2fj/BhWo1Wqo1WonS+4a2usrXY7sID1dBY1G/CYgSUDt2hKOH8/YHZz03126JEnQaDQZLmNWNHYsUKiQBI3GdXftS5bon3fsCNSqJWH0aP37v2+fCt9954OaNcV6wxt1w88BAKSlpQGw/R3UaHz/O14DtVr671j9udTqdIvr5M/no3tP5PZLS9NfU61Oh7P/RKSnW7+OvfSvX4JabfxZT0uTv4bpa9A+d7YsH33kgzt3jD9H4r3hv6PezFvqT612zXcyK/KWOiTLsnsd2vu6FQmWwsPDHdo/Pj4elStX1i2HhITgvo2fNadOnYoJEyaYrd+5cydy5szp0PXdZZcn/zSdRURGlkR0dFEAQHJyKqpWvYno6AouOXdMTIxLzpMVaTPsudO2bcC5c8/w/vsXoFIBX31VB4BoRXrhhdM4fboIChZMQuXKj3H+fClERxfRHXvs2CWUKSO+gwcOlMCRI8Xw6aenERRkfDMfHS3OuWgR8OTJFVSo8ATnz4ciOrosAODVV4EBA87h5s0QREeH/1eu4xbLfPNmVURHB1vcLz1dhejolwEA06bFoE2b6069N9euVUR0dB6b5bFF+/ovXozBtm3GZbF0DcPXsGfPWURH19Btc6Ysp0/XMVtneB7+O+rdPL3+1Gr953nv3nMoUCBZ4RJ5Hk+vQ7Itu9Zhkp2peRUJlhzl5+eHwMBA3XJQUJDNFzhy5EgMHTpUtxwfH4+wsDA0b94cISEhbiurPdRqNXbt2oVmzZrB399f0bJkdX5+Kly/Ln7xb9dOg6pVi+HAgYz1PpUkCTExMShYsKCutZOUoVYXQtmypfDCC8CiRfoWjICAFrhyxQdXrgDDhqXj/n0Vbt3S13udOnkQE7MTzZo1w6JFQShQAFi5sjU2bhTB0l9/qRAWJqFQIf059+8vhE8+SUfOnCocPao/1++/N0P//hqcOSPWxcW9gQYNJISFmZd39259a0zr1q3NtqelAUuXimvev18IrVpVNOvKplYDy5f7oGZNDV56Sf59OX7cB4mJlq9jL+17WrlyQbRuXdFo27Fj8tcwfA2NGzfBunX699CZshjWq+F5+O+od/OW+ktNBZYt036eG6N4cYUL5EG8pQ7Jsuxeh/F2prL1imApf/78Rr/iJyQkICAgwOoxgYGBRgGWlr+/v8d8IDypLFlVy5ZifIlGA/Tq5YOICMAngyP1tF3vVCoVfDJ6MsqwUaNEHRhWxcqVPrplf38f+Poab/fz88Px40Vw8GCgUR36+/vg7FkxAarpObXb/fzM1/v56a+3fr0P1q8HtmwxL6uPD4zKZUqlMj63v7+PWbD0xx+i9Wz7dl/ZawAwer1y15Ek+8YTac/h6wv4+/uabdNu//dfH1y7BjRoYPwa/P19zF6Po+S+Yobn8ff3x9On/jh4EGjeHAgOdvgSpCBP/39Qkow/zx5cVMV4eh1md6dOAf/8I6bssPTvfnatQ3tfs1cES7Vr18aaNWt0yxERESjOn3fIDr6+wAcf6JcLFFCuLORZdu0qhUKFVGY34zduWD/OYCikVY8fA/nz297vwQMgRw4gb177zmuri+PWrcDZs/rlP/4AmjYV69VqkVXw+HHgu+9cF1gMHCge/f2Bl192zTkdMWKEeF8uXxYZFImISNCOSClTRpl/n7MCjwqW4uPjkSNHDrNIr127dvjwww+xe/duvP766/jmm2/QokULhUpJ3qxcORE8FS4MVKsGdOqkdIlICVu2ONcieOiQ/dn84uNtB0tPn+qDeUutRI5asMB4eeFC4Pp18+x9u3YBHTq45ppaf/+tzH/G2gDyzJnMvzYRkTdwxXyF2ZVH9SGqVq0atm7darY+NDQUs2bNQuvWrVG4cGFcuXIFo0ePVqCElBW0bStu6IKClC4JKeXMGefGmk2bJr/+zz/N19mT2vzWLdv7rFgBzJ2rP58zE73Kjd3NjAljlZiU9tAhYPJk40mIiYiInKVosCRJEkqXLq1bvnnzJjpY+KlzwIABuHLlClavXo3IyEgULlw4cwpJRNmKMzk7rjuXtM7It9+K5Aim1q0Ddu60b14jV3n6VHTby6ioKMePOXkSmD8fTqdonjYNOHYM+PVX544nIiIy5FHd8GwJDw93OO04kTW1a4ubMyJAZL7KLKZTdP31F1Cxovy+gPPBgz3+/FN0GaxdWyyPHy8GBGeUM607EyeKx2LFgPbtnb/206fOH0tERKTlUd3wiDJbt25Kl4DczZF+2u+951zLkhxbXdAuXjRfl5Bg+xzOtNbIefJEPN65A3z/vT5IAVwTKGUU+9cTEZEn8KqWJSJX47ilrK9XL/v3TUwEzp93X1kMmbYs2cuecU72+P13oE4d+a5/ppxt1TIN/lztwYOcmDXLu37z27NHfMYGDwb8+D+wYtLS+P4TkX28638ZIhcrUULpEpCnOX7cfec2bLVyRcvJo0cZO37ECPuSMDx4YL5O7jhJMk6tvnOn82Wzp4Vv6dIXceCAd00MPXu2CJj271e6JNnXypVAx47AzZtKl4SIvAGDJSIiNzhzBrh7V6TTljNrlu1WLMOA5OJF85YabRIDSRJB3vLljpfzxAnH9n/61Hqgt3Gj42WQY+fE6nZLTgYWLwYuXbK8z5YtwIABmdMF0F2tbn/9JV7DnTvuOX9W8Ntv4juzcqXSJSEib8BgiYjIDW7fFpO1Dh2qHx9kau1a42VrGe/mzzeeYNnQtGnAV18B69c7Xs6rV/XP7Wll6tFDdG189kx++7//OnY+S/bscf5YOT/9BGzeDHz+ueV9Fi0C7t1zLui0x+bN7jmvoW+/Fa9h5kz3X4sy39OnwIULyqTlJ8quGCwREbnBvn365+++K1o2bDlwwHj58GHjZUsBiul+jjC86WrXzv5WFbmueSqV8evObNbe47t37T9Perr17ZcuicmJLbUOpacDZ88Cz58br1+8WP/c3Te7ht0hKevo2xf44gvg1CmlS0KUfTBYIiLKBIcOOX7Mt9+6vhymrlwxXv7iC/uOk0v6YE8AkJ4usu8pGVTZQ5JEGeVa+z7/HNixA/jxR/ljf/sNGDMGGDvWvWV0hchI0SqZnbMPXrwoWm5tpbqPjxc/aGTmFAOmtD8IMFgiyjzMBUNElAm8pduMYTc6a2y1vljy119iXqc//wQaNRLrrl8Xy127OndOd9i7VyRjAMRYJkC0JJ07p9/HUrfJXbvE4+XL+nWm9a/05+H0aVHX8+eL5eRkETRlRyNGiEeVSoz3smTUKJFFr21by11iiSjrYbBE2V7fvsCSJUDPnsCKFUqXhrKqrPDLvbXkCHJMu6mdOQPExBivkyRgyBDx3PQ9On3asetZYys4uXbNeFluHqxRo4wzqNkb8CxYYJ5lUelgafx442V7Pp/Pn4uWx7p1PSuwdZZpxkW5rqWGtGn2Dx1isESUnTBYomyvfXugYUMgTx6gbFnv6DpD3mfNGiAgwLXn3LYNKF3atee0xlpyBMD2nE3jxpmvM0yhbZqZz/SG3hEJCSKBxsmTxhPu2lM205voQ4dEgoh79xwvx507wNatjh/nDgkJQI4czs8vtH27aAW8fj1rBEuZ6dEj0YrXpg1Qo4bSpfEsp06J96dFC6VLQiSPwRIRRKAEAP/7n7LloKzNHWMdfvjB9ec0Zc+cR4BxFzV7mbbouMqJE/rga/Nm45acxEQgONh4/6dP9c9VKuPJf6dNc74cQ4c6fywgbiRv3gTeesv+epDz77+iFb1kSZGcwh5PnoixaQULimVrwfDOncCxY6JLW2Cg8+XMbJGR7r/G06dA//4i6cbx4/punY5ytuurp5swQTxWrAiUKqVsWYjkMMEDERFZZW+XMU+9mTMNUrt0sX2MaeILZ1nK0GfrPX3yRLSMTZggugc7E4gaOnJEPN6+bf8x774L9O4NJCWZbzt71nh57lzRivfHH04XUREbNuif2xuMOtqFsm9f12QnHD484+fwZHFxSpeASB6DJSIisioxEYiKsr2foxOh2hojYs2CBfb/97VuHRARYbzO0txXSomOFq2E2q5+gwYBq1frtz965LprGbai2Vs2wDhIGDNGfl+5wOrqVeC774xvhiUJSEjw1y2npor9lB7L5Q72TBtgD0sTXJO8xYtF12Fb3YOJbGGwREREVt29C4wc6frzZmSQ/I4dGeiTBuPJeE1lpLsbYN8N/7NnYgzRvHkia97kyWJMkLb1wDQ5hkZjfo6TJ0XQ8v331l+PqQULzNcZvmZJkr+esz77DNi9W7Q+aU2f7oPvvnsJp06JC48bJ/Zz5fiu27dF8h5Hg0PKGjZvFklpmGadMopjloiISDGbNjl+jLtbhTIaLNnj99/FHyDmbNJKSJDvjvTnn0CzZsbrDBNX/Pmn9bEwhq/J1pxfo0bpW5MsncMZhgkyDh8WJ1u/XoVXXtG3XO7YIZIguMKHH+qvq03gYW0upYcPxV+RIq65PumlpwM+Pu79bj19CoSEmF/D0cBfkjLn3wDyHmxZIiIir2JPl8CMMJwfyRGJicaJIZz13nvm665fd+5cW7YAixY51r0tKko+WLLnHOvWiSyGcl2f7t+3PRbMFe+fKW0SkYcPzcerGd4U37sH9Otnu9tWVuwq6E6pqWJqjlGj3HeNixeBHj0yPlfYhg1irN7du64pF2UNDJaIiIgMPHxo336mN839+gGDB5vPJaUEbdkWLRIBk70JK+QyNjoSHGg0Yn6sgwfltw8bZvschnNZudJff9m3n61gybBb34ULIhGHpyY38QQXL4r3zNaPHBkJQjdvFo+m0w84et4ffxRlXbTI+bJQ1sNgiYiIvIq70o1r2dsF5/JlMXhf283HdJyRq8uUkADMng3s3Ws7DX1SkkjnrWVvkgG58UxqteM3stbKZ+tcjgRLkiTGQ1n7TFi6nkqV8VaiL74QiTh27crYeVwpNVVMIEzOYzc8MsQxS0RE5FWOHs34OVx1M9SpE1CmjMj25k6pqUC3buL5nj1iklxrHj82Tqhgr927zdd99pmYg65qVfNtsbFivJQpa+/vunX655cuqTKUFv30af17v2qVOHeLFkBYmH4fa+nb5VoR//4bCA0Fiha1vxz379u/r7t17y5e82+/AUFBSpeGyPuxZYmIiLK1jLYuXL8uJhvNTHJd/TLS/U8b3Fh6LyIizLc9eQL06iW6oTli5Urj5dGjzfc5c0YEhZYkJ4vucoatULNmiYQhH39svq+ce/fkx6aMGuV4psYNG1yXItxZ9++L1kdtORxN5Z9VOfP9ZssSGWKwRERE2dIvv4jMcKY3187cXGV0YLkr9O6dseMd7UZobfzR3LkZG3s0bpzocigXzCQnixa9Pn2M60qbPt3eeXUMs/M5w/RzsmaN88dmVHQ00L+/vvXRlthYZbrq/fqr5fphgEKeisESERF5FVfMAXTxoujKNm2a+xIKeJM7d8SkuNbs22e8/O+/1vf/5JMMFQmA6E5oSpsZ8PFj41aqzMxSd+YM0K6d8Tp7W3JOnhTBnq0U7o6wN4EHIAKlXr1Ed73MtmqVmE9MTkbqjwk2XGvfPvnutdkVgyUiG0qXVroERGTowQPPOEdWY+uG29GWGGdvYC9etL79xx+dO68rWy608zY5Y+JEICVFBOrOyshr0WalU6udP0dG3L7t+nOePev6c2ZXaWnAzJlismt3z2nnLRgsERFRtnP4sNIlIEsMWx4uXBCTyxq2MFkK6my1TLi75clVwdidO6JL5N9/W+4aafpa5K7tqfNBuaNcSgV+WZFhyz2zKgrMhkdkg1w2oW7dLmP37kKZXxgiIjfxhPmhTGnHAfXsKeaLssZTgwNH3L0LDBpkvM7W6ybXj3fi+CkyxJYlIhvs6Xf/zTduLwYRkdeJjc28a9kKltx9A3zypOjeefu2yBDoTPApN3Grs0Gg4XGPHgEzZjg2tsme85uWbft29845ZW/yDiJXYrBEZEWDBkDx4sbzbXz+ucbsP4hKlTK3XEREjjh9WpnrPnvm2vOlpFjeZpi6e/9+117XXpMmiW6Dq1eL7ISWkhnIsRQI9O9vOy25rUDw88/Fe2Itg6EjJAkYPtwHS5dW1f1/mJAgkoTMmWN70mRnxMQAHTuKLImmDF//5MnuTfggScDmzcjQ/GDeIiu01roCgyUiE5Mmma/7/ntg6VLRHeLVVyX+A0JElMmePAEmTLBv3xkzXHNNR8dsmGbEs5VhUGvOHODNN4HLl823PXgA/PWXY+UwFR2tf+6KFrZnz4B//lHh4cNgxMWJdYaBrL3BiuGkwLb+X92yRexjbf4tADh2DOjSxb7rW2LtPTp/Hli8WH5+sKyAXRDNMVgiMlGjhvm6gACgkIUhSs5mZiIiyupceeMVGSluVDOrLPHxQI8ezl/PHjt3ikdt1zVLgYBpsGT6WuRe2x9/yJ9Lm3rdFkkCjhwRKeIlSRx34IBrB/2vWOG6cxly9QTBsbHA8uUi6LSVMt8RDx5Yn98sPR0YO9ax92nrVnFf4syPuuvWAX376pe151Crs3crE4MlIqfo/2cqWFDBYhARebCff3bduVzdpc+WMWPcf425c+3bz7TLlz2p7y11Rfz9d/uuefgwMHWquHlesgQYMgSYPl2klTa8cY6MVL4pwlog7Iqb/EmTgPXrXduaFB0NfPCB9YmEz5wBIiJEEGOvBQuADRuAf/5xvEwrVpjPbZaUBHTuDIwY4fj5sgoGS0ROyM6/sBAR2cuVKdrnz3fduexhbwtMRjkzl421sVuukJxs3Iq3ebP++bFjwHff6Zdnz3bNraRhwHP4sOhyaa3VRSs52fVjpEyDL+1nwZXzs8l1uTSVkZTormoBPHNGjKe7dMk15/NGDJaIiIgoy3N3gOGsIUMcP0Z7M6/RGI/7yYjHj8WNcXw80KkTsG2b5X1PnLB+LkkCEhOBffvMWwTt+bHx66+BU6eAZcv0iS8sHbdjh+3zKSUxUYy10o7r8jYpKcCffypdCuVxniUiKypUkF/PliUiIu/x1VfA8eNKl0KeabcnR3zzjWiFeeUV+e0JCYC/v33n6tlTPFo6l6OmTBHjzDJi1y7xZ20KD3dMSPv0qUgFX7Mm4JOBZoXvvgOOHhUB3bx5GSvTnj1A7dpASEjGzuOIFSuAs2cz73qeii1LRDLmzwcGDgTeeMPSHsr30SYiIvt4aqCUUdpujkePym+fPl20EjnC0rkcZS1Q0v7gaPjD48aNwLRporXMlFy6cEC0Wj19ar0czvy4eeUKMHEi0L69/cds3Qp89JFxK9KxY+Lx9m3r5UpKAu7ds37+2bMzNmbKmffhzBnnr5eVsGWJSEaJEuLPWeHhwI0brisPERGRo5S62bWWcCEtDRg0SPw/aUhb1tdekz/O8GZ/7Vrg7beBrl0zVk5nWEq2sGCBeFy9Ghg82LFzvv++GGM0Z454X/bsEWPGatUy3s+R+wr2gHEdtiwROSE42Lzd39dX/3zOHPnj3n5b/7x4cTEXhCO/XBEREd2+7dkD7q3dqJ89C9y9Cxw8KL/dUmICw2Qhq1eLgMtVUlKAqCj79r1/33jZ9LU6k2xC+5q1k0fPni0CpgMHHD+XJe6cP+n6ddFlLynJfddQEluWiJxQvPgzvPeeBmFh+t8bvvkGWLRIP0fB2LGin3znzqJZvlEjoHJl/a9SgYFA9+7i+aZNmfwCiIjIa8XHA59/rnQp3MNSl7vYWONlV2am++or58bmfPedaAH6/nvHj7Wn5ceV6fLd2dKkTVKSmOjaINZTMFgiclLHjpLRwNkKFUT/cK3atcV8FoYtToY4SzYREWU3hgktXD15rLOsBUrWsgLu3i0eDVvJXPl/u1yAk5YGXLsGlC+fseQT7pBZ6fYzm4e9zURZi6VACZD/B/XDD91XFiIiIkP794tkRtOmufa89rZiaLudZYanT4H0dJHOfOhQ85YqS+yZ38swI9/evSJBxJ071t8He4IqueNnzQKGDQNWrbJ9vDXJyUDfvr5Ys6Zixk6UDbBliUghbFkiIiIlzZghHu/ezdh5rl4VY2y0evTI2Plc7eZNkamuQgVRVgBYuhQYMcI15zcNqIYNM99HrQb8/Bz7v//iRfN1f/0lHn//XZ/uXcvauKsFC4wz/HbqJDIPRkfnwb17QOnS9pcru2HLEpEHsdYSRURE5Ik++8y4u5p2IllPsXeveNQGSkDmJyPo1An44gv9sqvHECUlASNHWj9/fLz8sb/+6iObsp0EBktEmUybEa9PH/NtYWHi1x9nBotmxIoVYk4JIiKirGTXLuvbMyvFdnq6fEuRIUdanUz3tSf4++Yb+fUHDqjwwQe2j//+e+Drrx17zx4/FkkwvJliwVJUVBRq166NfPnyYfjw4ZDseOerVasGlUql++urTTtG5EV69gTWrweqVNGvmzkTGD4cqFhRpBQvVUq/rXdvEcyY6tbNePmrr2xfu21b+fX58wP/+5/t44mIiLzJ2bOWgxBJcnxOJE9hT2C1cKHx8rlzlseJ/fuv7fP9+adI4W5rAl2tRYvEPc+oUeLa3kqRYCklJQVt27ZFzZo1cerUKVy8eBHLly+3ekxSUhKuXbuG6OhoxMXFIS4uDnPnzs2cAhO5WECA8XL58kCDBvL7liwpghlbypa1vU/z5rb3ISIiykoSE83XnTkDPHwo5qzyFBlp5TINnsaMAf74w3y/8eNF8omMGDhQ/j019OgRsGWLfjkyMmPXVJIiwdL27dvx9OlTzJw5E2XLlsWUKVOwdOlSq8dERESgWrVqKFiwIPLmzYu8efMiR44cmVRioszXrx/QpAnw0kv27Z8rF9Crl3vLRERE5G3+/FN+vT1dz1ztwgVg5Ur7s/FZkpYmgqs7d4DLl4HoaPuPzWiwBAA7d5qvu3IFWLJEX76sQpFseOfOnUPdunWRM2dOAKJ73UUbHTlPnDiBu3fvomDBglCr1ejatStmz56NwMBA2f1TUlKQkpKiW47/b1SbWq2G2jDHowK011e6HOSczKq/Vq3Eo/YfHI3GOPtD4cIajB0rYfx43//Kk442bYClSy1niVCr083Oo10vd42sStvtV5IkaDiq1SuxDr0b68/7sQ6dY20y4bQ0DU6dkuz+v7hNG+fKkJqqgUbjk6E6XLIEKFcuHRUrGt87bNgA9OyZjrQ04/WpqRrExkrIk8e5MruDvfdxigRL8fHxCA8P1y2rVCr4+voiLi4O+fLlkz3mypUrqF+/PsaPH48nT56ge/fumDVrFr4wTC1iYOrUqZgwYYLZ+p07d+qCNKXtsjXqkDxaZtdfYuJLSEzUz4IbH38cCQnAG2/kQs6camzbJn4ciI6uY/Ec+/ZFIjq6mtn6bduO2zzWUFBQGpKTvX/mgZiYGKWLQBnEOvRurD/vxzp0nYiI29i3LxDR0YXdep0jR/5GdHR53bKzddi7NzB69HGze4dt247jyZMAREfrB0MvWCD+3nvvIkqWTHCu4C6WZGdKRJVkT2YFFxsxYgTUajVmzpypWxcWFoZjx46hePHidp1j5cqVmDNnDk6dOiW7Xa5lKSwsDLGxsQgJCcnYC8ggtVqNXbt2oVmzZvD397d9AHkUpeovORno0kX/K83Gjemy+33+uQ+uXpUf+Tl7djru3FFhxgzjHrjac3XoYN+vWXnyiAn+vJUkSYiJiUHBggWh4oRXXol16N1Yf96Pdeh6776rQXS0Cn/+6d7387PPNJgxw8cldbhxY7rZvcPGjemIjgY++ED+nmLmzHSUKePU5VwqPj4eoaGhePr0qdXYQJGfhvPnz48ok5mzEhISEGA66t2KQoUK4Z6VdByBgYGyXfT8/f09JkDxpLKQ4zK7/vz9gUKF9P2c/f3lhxz6+gI+FkYj+vv7oHFjMQO46XrA8nGmAgLs39cTabsbqFQq+HjzC8nGWIfejfXn/ViHrufv72P1/3BXuXDBBz4+rqlDf38fs/Jq11k65eLFPpg+3anLuZS993CKfLpr166No0eP6pZv3LiBlJQU5LeS8uuVV17BHYMRaUePHkUpw/zKRAQAeO018Vi0qOvOOXq08bISg2KJiIiyOnvTcmeEXHIGVzOcpNiUt8XWihS3QYMGiI+Px7JlywAAU6ZMQdOmTeHr64snT54gPd28e1GVKlXQv39/HD9+HCtWrMCMGTMwcODAzC46kaLq1ROPYWGW92nbVqQGnTHDddc1TTzpykDM0CuvuOe8REREnm7rVu+fwBUAbt3KnKAvsyjSDc/Pzw9LlixB165dMXz4cPj4+GD//v0AgHz58iEiIgI1atQwOmb69Ono1asXGjVqhEKFCuHbb79Fz549M7/wRAp67z0xJ5PJ18OIjw9Qs6Zz569c2XyG8Vq1xGS5riJ3Da2gIOvHdusGrFnjurIQERF5Cm/MlSH3w6ytiX69rWVJsXRW7dq1w7Vr13D69GnUrVsXBQoUAKBPRWkqb9682LBhQ2YWkcjjBAQAr79u//4jRgAPHog5HQAgd27zfcrrE+Jg6lQxT4I2tWmhQsC4cYA92TWDg21PUgcAH38MDBhgez85FpJlEhERkQL+a+twiLflA1E092+RIkXwxhtvKFkEoiytfn3xWKoUkJQE/PebhE758sC0afplHx/jgKpBA/uvVaQI0LOnyJR37Bjw88/y+xUsaP85TZUu7fyxREREpDyTHG8ez/snSiEim15+WX59sWIiy54lXbuarytXzvL+//tvSoUyZcSvTQ8e2F1Enbp1RbBlaO1a4Plz2y1c330HDBni+DWJiIiI5DBYIiIjhj1h5QKp4cPl+xuXLGm8bK2Z/ZNPgPv3gV9/tV6Wd98VY6aCg8WfreDLzmnaiIiIiOzCYImIHFakiAhkcuUSXfl27wZ69DDex1qw1KSJeLQVLHXunLFyEhEREWUEgyWibKxECfN1fnb+q2AYyBgmiXBEaKh+kl0ACAkB3nhDdMNzZLwUERERkTt4WfI+InKFb74B3n4b6NjRfFvRokDz5sCbb+pbhwy73QUHO369ESP0zw2DsQkTRMAEiC50XboAL7wgxigNG+b4dVydYcfSWC9TtlKeExERkXdiyxJRNlSpkviz5KOPjJd9fYHRo4GUFJHtzh6DBwMjR4oMefXrA1WqiKDLMPAqWRL4b25qI5YCspw57bu2qzRvLtKc9+5tfT8LMx5YFBQkxmIdOuR82YiIiMj92LJERHapU8exrnFVqwIbNogWLEDMkWRvoGVJnjxinqZOnew/pkABoE0b4LXXnLtmwYJAy5aWt3//vePn/O03keTCXkWLyq//4APHr01ERET2Y7BERG5j7/gnRzRrBrRvb/l6rVoB4eH6dVOmAP37iyDLkjZtrF/TWve+UqWsb7fURS8w0Po1tcaPFy17cmyVm4iIiDKG3fCIyOvkySPGOy1aBNy7J9b16iW6+A0aJJYTE4H4eH2rjLVxRf37i652Z84AR48Ce/ZYv37nzmIeqZ49HS97rVqO7W8pUAJcO0bL39/2PFZERETZDVuWiMgrvfQSULmyfvnNN423Bwebd18bPVokbZALMvz9RVfDhg3166pUEY+m+1euDCxdKt8tcdUq42XDYz/4QMxTpRUWJh6tjcWyFRCNHGl9uy2dOgHLl9tO405ERJQdMVgioizBnlaWOnWAMWOA7t01dp0zVy7xaJgVr1kzEahZkjev8eS4huVq0MA4MBo3DmjaFJg+3Xj/SZOMz6ltLZPz6qvmrU/du1ve31StWmJclzu6TBIREXk7BktE5LUKFHDuuLfektCixU2793/pJZFuffVqMfbJNDArWdJ42bCVy1oQV7gwMGSIaGFq1Eis69sXqFHD+PgXXwR+/x3YvNl2WStXFinY7eVoJj8AmD/f8WOIiIi8EYMlIvJab70lWmbGjnXsOJUKqFTpkey2ihVFl7zSpU33F5PmyhkxQgQ7330nlps3128zbLGx1nrzySciCGnbVn67v7/lwKt2bcvnBSwnxADEvFaO+OIL+cmMAdFSRkRElJUwWCIirxUUJFpmbAULcnLlSsPXX6dj7lzzc/7yiz7wsUehQsDQoUCZMmLZMKipWFEkgujZ0/qEvj4+IgjRHqsNzMqWtX19a2nIQ0JEa5UcZ7rf1a1reX2tWsA774hla+nWXaFaNSeaxGzIndv2Pq1amY9LA4y7UhIRUdbBXupElG1pW5FMya1z1KxZwJ9/Aj16ODe/1PLlQGqqeYA1ciQwbRowbJh+nbUgzJr8+R0/xnR8VKVKIqDTdv3r3h2oV0+kVN+xw/z4oUNFK5y2+1+7do6XAQAaN5agUt3CuXOFnDuBjNWrbZdn0CAxObMpZ+uAiIg8G1uWiIjcoFw54MMPnZ+I199f/gb81VfF+CXTSXb/9z/xqJ17SZtp75VXLF/DMDOf3HUAoFo1kVYdEIGfqfBwkXpd+zpVKrHOx8e4/GPHisx72myDKlXGUp+HhUmoU+ehXa1B9rJVnqFDLW9zZuwXERF5PrYsERF5Gbm5l8aOBaKjgWLFxPLUqcCJE+ZBlVbjxuap1Q0NGSKyANapI7ICmqZmt8eUKcCCBWIOrEqVHOsu2aEDsHEj8O67Yk6rO3fE+rlzxessWxa4csXxMgFAjhzA8+eOH6d9LxkYERFlH2xZIiLKAvz89IESIFp6mjWzPhmvNTlzAk2a6NOnO6NMGZFFsFIlx4/t3Vt0RezcGZg4EQgNFYFT6dLGqdztDVyqVdM/nzZN/9yV3efsea8++8x117OlkOt6KLpFrlycBZmIPB+DJSIiUoylSXVVKn1q+NBQ4McfReDkiH799M87dNA/DwsTLWsqFdC6tWPntGb+fDHxsCXt2hlPeuwOo0frn9t6v7p0AapWdW95rKlQIU52fcGCmVwQIiIrGCwREWVDhi0tSnr1VeDbb0W3unfftbyfveObDLsoarMTAqIL4LJlwIYNohXu00/F2K/QUMvnciQjoiSJCYnr1NGvM23VK1fO8vGGwZwjevUyXn7xReMyWfPKK6K7prXU8qYMs0eWL297f+1YOlPVq0soWvSZ7DZL6fMt0Y6X8/d3fu41IiJLGCwREWUjM2eKeaEaN87YebTjj1zRMlOxIjB7tphQ11GGAUGDBsZJGHLmNN43NNT2vFf164tHw1Tw9nAkg+InnxjP4wU435rSsSOwcqVIXb52rfFrDgzUPzdcv2yZ6B6pfX3vvWecXdGa0qVF1sDffwdmzLC+b506wIQJ8tsMu4yacjTxx+TJIvCbOVN8BmyxNI7PEtO6IqLshcESEVE2MHWqmDS2fHkREGQkEx0AjBkjbs5LlXJN+ZwVHq6PloYPN27tKFMGePttYOBA+883fDiweLFIb26JaYuNSqVPlmG4rVkz+eObNBEtNNqb9g4drNdHlSr65z17mree5MsnJhfWjr/q1UtM2GwYkBgGc6GhxuPIAgKA11+Xv7ZhtkFtF7+QEP0kya1aiXWWgj2VyvFxc45+NkuVAkaNsj+oGTDAepBvWm/ffutYeYgoa2GwRESUDVStKiaNtaZ/f/H48ce2z6dSecbcQkOHatC6tb57WNGiopVk0iSx3LOn9Rtj7SS72i5yPj5AkSL67QEB+ueWbuIHDJBf3727yFKoZRpkDR8uWmn69LFcvsBAEZhqvf020Ly55f0B0dr0/vvG65wNjvv0EUHdpEnGXQy1evcWKfLlJuUtXlw8lihhvk2SLJfJUtc9OaYZFu15nSEh1gPojz4yXjYN9gYOFC2hRJQ9MHU4EREBEHM0NWkiUmt7i/z5zW98LbWSWDr+11+Nu6wZWrtWJG4oWVI/HspalzvTbnCGN/NyLVIhIebnmD9fBKLr1wMtW4rnixbpy/j220B6unFWQDmG5fz8cxG4GSa9MPXCC+bp2ENCxLGWBAWJMgJA06bAhQuiRSsgAOjaVf865YSEmM/uO2uWeK9r1wZOntSv//JL0d1Oq3lzMUbMdLyV4bXeeAPYutVy2eWULi3OUbgw8O+/8vu0bg3cv+/YeQExofEPPzh+HBEpi8ESERHpeFOg5CrWXrO/v3lLm5+fuHH/8kvz/XPnFuv9/PRjovz8gLQ04+QLpmrW1B+vbYnp21e/3XBOrIAA68kwtMLDRfa90FBx7XXr5Ofo0vr2WzGe7dIl/TpHWqSGDLF/X0kCwsPj8f77GoSH+yA5WZRX2xo1apTx3F6m5ShaVASNpjp0EEEmIFqoDIOlRo2MW+XefBM4eBCIjRXLderouxqOHy8yMHbpYv9rsqVVK+DpU9GaSETeg8ESERF5BE+fF8hQtWoiMcXly/qufFqmy2vWAAkJ1l9fsWIi8YLhGKGMUqmM53WyFihp958yBXj0yDhQcxeVCujQQZJtqTNNvpE/v/79tiZvXuNlHx9AoxHPDZN/AKILYe/eIlnF9u3GLZQlShh3oTSlzcBnTVAQkJxsez8i8mwcs0RERB6hUCHgq68cS9mtpG++AX77TdzIW5Mjh32BYGio5e6AmcXPT3RB08poIhBL57B3MmFApJcvX954Ti57sznaU/6OHUVSD2tpx7XzZ2nHl5mO1+vRw/wYa2PRAOM07LY+Q67g6yu6lXoSbUsikSdjsERERB6jenXHUnYryZlMb97G2jxU9nI2WBoyRHSr++ILsZw/P7B5s+hmZ09wYU/rj73athUthHLzYTVsCLzzjpjsGBAtWCtW6MdyWZLZKcnz5XMsSNVy9Y8X2vcJsD4ejrIubRZNb8FueERERGRk6lQxlsddqeHtuWlv2tR8nUplnKFQzrBhIgHDCy+ILpGHDxvfoDvLtItkr17AH3+IeaoAMe/U7dtAhQr6ALF7dzFGqXp1sWwtuJ47F7hxQ2QffPRIzJ/1118ZLzcg0s8PGCBaxPLnBx4/tv9YuWyGWjVqxOD+fevNpnXqAMeP65fbthWJQypXBp7Jz0tsU69eotsqeSdH5qXzBAyWiIiIyEjVqq47V7Fi5ln23MkwG+JHH4nXUq+e66/TsaP408qRQwRoht55B6hRQ99a2qqVyPInl8mwdGl9a1PhwiIgsCdY+u4728k1vv5a/3zpUpGOPipKfl/D4KZ6devBqVzQ26ULcOCASKDRooUYNzZoEHDnjthevLgY8weIMWa1a4tAdO9e66/BUMeOwLVr4v2ZNQv49FPr+zsaIJJ7uaJ7b2ZiNzwiIiJym759RUp6wxv2qlWd6A/mhOBgkRI/X75MuZwZlUokptAGHIGBIpOitZTnWqZdIFeskL9GmTLG2RJtMczUaKhhQ2DBAuOxYQ0aGO9jGgwaBkstWwLLl4vWtEWLRGDo899d5sSJ+v3KltU/V6lEIg3DYMdWtz9tF8xhw4BfftHPkWbJsmViTjNnyHWltDZvmy3elMTGnSpXVroEjmGwRERERG4TEgJ88onoCvbjjyIt+OuvZ06w5Om0Y6B695bf/sknYuzVzJkiSJg1S36/H34QY6rWrRPBitaQIbbndurbVwRb770nWn2sZU3s1s14uWLFOFSuLKFaNdF6ZClJhrMtCS1aAPXrG6/TBmgqlfG8ZpaEhorPnqlPPhHn16pTR7S6GWreXIxBe+01/TrDAFIbDMol85gxw3yM23ffiRbDzCY3zYGSXnlF6RI4ht3wiIiIKFMULCj+1GqlS+IZevcGOnWSn5wYEC1yjRvrg41y5URAlJAgbrq1kx77+enHVBUrpj9ebtyXqfbtzVu6tLRBRv36wK1b+u5zWuXLx2HIEA38/X2tBkSG2QNtjTkz3LdAARGgPXliudsgILo6nj0r5hM7f958u2HZQkPF/g0bigApLk7MwaUNyqpVAyIjRZfIcuVEJsZGjcScXKaqVQPGjRPvv2mglSePCKI2bjQuR6VK+uU2bcS4N1M//6yf1NlRNWqISavz5RPdFAMCzKczUJq3dcNjsERERESkAJXKcqBkuI+hwEDxt26dfOBRt65IymB4U27KVpbDNWtEgKJN7T1ihGjRUalEEPD0qb5s2j9rgoJEqn2VyvLg/mHDRBBYuLAIUv75R7Ti5M8vEo58+aUIYgxbg7QmThQBuKWWN0MNGwI9e4rnuXKJ8VuGJk+2frxp0hNtl8aRI0U5AZHEQpuC/9dfxcTWVaqYp5zv3x/Yvdux+biaNhXHWNKgAdCsGZCSIrqAasfH1a8PHDpk/dxr1gA//QRs2ya/vXRpEdx/+6395Q0IAGbPFue2dX1PxWCJiIiIyMtYmpMrIEB0vbMWwPTuLW6mLbU85c5tnv1Pe76JE4H584Fu3dJx+7b95bUWvAHGiTmmTwcSE40DyTFjgKtX5bvU2ZMlUcu0dcxev/4q3rNcueS3v/qqyHwYHGzclTFHDjGPlyWDBolulobBTFCQSEwSFQW8+64IgI8cEd36nj+3HizVrCkeAwNF0Kb1+edibNitW+YTNGvlzi0mZ+7VSwREJ04Yb9fODWZPsNS5s6iXt98Wr8fHiwf+MFgiIiIiykJstfTkzu38HEdlyoibZbUaDgVLjvD1NW9xCwqyHegYpjnv3t04W+Hy5cC9e84HSzlyiD9AjJVKStIHJlq2WgkB87pp1EicJyREjBtTqURr1bhxwN9/i+DQxwcoWVLsb5icY8UKMQ7wwAGxPGKE5TnItAFl+fJi3OCUKWJ97doPUbVqQaOxWEFB5pkODV+btnXRzw9ISzPer3Rp4KWXxETN3tbdzhIGS0RERETk9Tp1AlJTRUuMaUtWgQKWE1A4av584OJF5xIVlCkjuiIadoXUBiKGWQ2DgsQYLFN+fsDateJ5cLDoyqcNlrTzedliWO48eVLRr58Yd2a6z8mTIlB7+23jVsjJk0Wg1r27SJRh6JNPjDMeZgUMloiIiIjI6wUEZE62ufz5zbP02SsgQAQ71rIO2mI49il3bn2Kc9Ouk9Z89hlw5IiEChUeym5v2lQEdGXLmreYlSolUr4bqlJFzGumHeeWlTBYIiIiIiLKJPaOr7LXhx86fkzDhkC9ehps2yafxl+lAv73P/vPV6tW1gyUAAZLRERERETkhEWLRJbCJk2s79ehg0hl7myLnJIYLBERERERkcOKFjUea2VJ+fKi+6E9Ewl7GgZLRERERETkVqbzTHkLL856TkRERERE5D6KBUtRUVGoXbs28uXLh+HDh0MyTeguY926dShVqhSKFSuGn3/+ORNKSURERERE2ZUiwVJKSgratm2LmjVr4tSpU7h48SKWL19u9ZioqCh0794dY8aMwZ9//omxY8fiypUrmVNgIiIiIiLKdhQJlrZv346nT59i5syZKFu2LKZMmYKlS5daPWbJkiVo1KgR+vbtixdffBGDBw/GqlWrMqnERERERESU3SiS4OHcuXOoW7cucv6XEqNatWq4ePGizWNatWqlW3755ZcxceJEi/unpKQgJSVFtxwfHw8AUKvVUKvVGSl+hmmvr3Q5yDmsP+/HOvR+rEPvxvrzfqxD75fd69De161IsBQfH4/w8HDdskqlgq+vL+Li4pAvXz67jgkJCcH9+/ctXmPq1KmYMGGC2fqdO3fqgjSl7dq1S+kiUAaw/rwf69D7sQ69G+vP+7EOvV92rcOkpCS79lMkWPLz80NgYKDRuqCgICQlJVkMlkyP0e5vyciRIzF06FDdcnx8PMLCwtC8eXOEhIRk8BVkjFqtxq5du9CsWTP4+/srWhZyHOvP+7EOvR/r0Lux/rwf69D7Zfc61PY6s0WRYCl//vyIiooyWpeQkICAgACrx8TExNi9f2BgoFlABgD+/v4e84HwpLKQ41h/3o916P1Yh96N9ef9WIfeL7vWob2vWZEED7Vr18bRo0d1yzdu3EBKSgry589v9zEREREoXry4W8tJRERERETZlyLBUoMGDRAfH49ly5YBAKZMmYKmTZvC19cXT548QXp6utkxb731FtauXYvz58/j2bNnmDNnDlq0aJHZRSciIiIiomxCsTFLS5YsQdeuXTF8+HD4+Phg//79AIB8+fIhIiICNWrUMDqmevXqGDJkCGrVqoWgoCCUL18egwYNsvua2klv7e2f6E5qtRpJSUmIj4/Pls2e3o715/1Yh96PdejdWH/ej3Xo/bJ7HWpjAm2MYIlKsrWHGz18+BCnT59G3bp1UaBAAbuOuXjxIu7du4fXX3/d6pglU3fv3kVYWJizRSUiIiIioizmzp07KFGihMXtigZLmUmj0eD+/fvInTs3VCqVomXRZua7c+eO4pn5yHGsP+/HOvR+rEPvxvrzfqxD75fd61CSJCQkJKBYsWLw8bE8MkmRbnhK8PHxsRo1KiEkJCRbfjizCtaf92Mdej/WoXdj/Xk/1qH3y851mCdPHpv7KJLggYiIiIiIyNMxWCIiIiIiIpLBYEkBgYGBGDdunOykueT5WH/ej3Xo/ViH3o315/1Yh96PdWifbJPggYiIiIiIyBFsWSIiIiIiIpLBYImIiIiIiEgGgyUiIiIiIiIZDJaIiIiIiLzUkydPcPz4ccTFxSldlCyJwVImi4qKQu3atZEvXz4MHz4czK/hGT7++GOoVCrdX7ly5QBYr68DBw6gUqVKCA0NxcyZM43Ot27dOpQqVQrFihXDzz//nKmvJTuJjY1FeHg4bt68qVvnjjqbN28eChcujDJlymDv3r1ufU3ZjVwdWvo+AvxOepJNmzahTJky8PPzQ40aNXDp0iUA/A56E0t1yO+g9/jtt99QunRp9O3bFyVKlMBvv/0GgN9Dl5Io0yQnJ0ulS5eW+vfvL/3zzz9S69atpR9//FHpYpEkSa+88oq0detWKS4uToqLi5Pi4+Ot1ld0dLQUEhIiTZgwQbp69ar00ksvSXv37pUkSZLOnz8vBQQESIsXL5YiIyOlcuXKSZcvX1by5WVJMTExUp06dSQA0o0bNyRJsv4dc7bOduzYIQUFBUkbN26UDh8+LIWHh0uxsbGKvOasRq4OJUn++yhJ7qlfcs4///wj5cuXT/rll1+khw8fSp06dZJeffVVfge9iKU6lCR+B73FkydPpNDQUOncuXOSJEnSsmXLpFKlSvF76GIMljLRhg0bpHz58kmJiYmSJEnS2bNnpXr16ilcKlKr1VJISIiUkJBgtN5afc2aNUuqWLGipNFoJEmSpI0bN0rdu3eXJEmShgwZIrVo0UJ3ntmzZ0tffvllZryUbKVJkybSd999Z3Sj7Y46a9++vdS/f3/dtk8++URavHix219fdiBXh5a+j5LE76Qn2bJli7Rw4ULd8t69e6UcOXLwO+hFLNUhv4Pe4/bt29JPP/2kWz537pyUK1cufg9djN3wMtG5c+dQt25d5MyZEwBQrVo1XLx4UeFS0fnz56HRaFCjRg3kyJEDLVu2xO3bt63W17lz59CoUSOoVCoAwMsvv4zTp0/rtjVu3Fh3fsNt5DqLFy/Gxx9/bLTOHXXG+nQfuTq09H0E3FO/5Jw2bdrggw8+0C1fuXIF5cuX53fQi1iqQ34HvUdYWBi6d+8OAFCr1Zg1axbefPNNfg9djMFSJoqPj0d4eLhuWaVSwdfXlwPyFHbx4kW88MILWLVqFSIjI+Hn54cPPvjAan2ZbgsJCcH9+/cBmNez4TZyHcP3WMsddcb6dB+5OrT0fQTcU7+UcampqZgxYwYGDBjA76CXMqxDfge9z7lz51CkSBHs2LEDc+bM4ffQxfyULkB24ufnh8DAQKN1QUFBSEpKQr58+RQqFXXv3l33ywwA/PDDDwgPD0elSpUs1pdpXWrXA+b1bLiN3Mvad8zZOmN9Zi5L38f4+Hi31C9l3Lhx4xAcHIy+ffti9OjR/A56IcM69Pf353fQy1SrVg07d+7Ep59+ir59+6Js2bL8HroQW5YyUf78+RETE2O0LiEhAQEBAQqViOQUKlQIGo0GRYoUsVhfpnVpWI/WtpF7WfuOOVtnrE9lab+PDx48cEv9Usbs3bsX8+bNw5o1a+Dv78/voBcyrUNT/A56PpVKhZo1a2LFihX4/fff+T10MQZLmah27do4evSobvnGjRtISUlB/vz5FSwVDR8+HGvWrNEtHz16FD4+PnjxxRct1pdpXUZERKB48eIAzOvZcBu5l7XvmLN1xvrMXJa+j2FhYW6pX3LejRs30LVrV8ybNw+VK1cGwO+gt5GrQ34HvceBAwcwfPhw3XJAQABUKhUqVarE76ErKZ1hIjtRq9VSwYIFdekb+/btK7Vp00bhUtGqVauk8PBwaffu3dKff/4pVahQQXr//fet1ldMTIwUFBQk7dq1S0pNTZVatmwpDR48WJIkkXUmODhYioyMlBISEqQaNWpI06dPV+z1ZXUwyaTm6jrbtGmTVLRoUenu3bvSw4cPpeLFi0vr1q3L/BeahRnWoaXvoyS5p37JOUlJSVLlypWlfv36SQkJCbq/1NRUfge9hKU6XLlyJb+DXuL+/ftSSEiItHDhQun27dvSe++9J7Vs2ZL/F7oYg6VMtmnTJilnzpxSgQIFpIIFC0oXLlxQukgkSdIXX3wh5cmTR8qfP7/08ccfS8+ePZMkyXp9zZ8/X/L395fy5csnhYeHSw8fPtRtGzVqlBQQECCFhIRINWvWlJKSkjL9NWUXMJmjx9V1ptFopB49ekg5cuSQcuTIIbVp00aXcpVcw7QOLX0fJYnfSU+xceNGCYDZ340bN/gd9BLW6pDfQe+xc+dOqXLlylLu3Lmlt99+W4qOjpYkif8XupJKkgym9KVM8fDhQ5w+fRp169ZFgQIFlC4O2WCtvm7cuIHLly/jtddeQ65cuYy2Xbx4Effu3cPrr7+ebfr1egp31NnJkyeRmJiI119/XZdylZTB76Tn43cwa+N30Dvwe+gaDJaIiIiIiIhkMMEDERERERGRDAZLREREREREMhgsERERERERyWCwREREWZ5arVa6CA45deoUfv/9d7ec29veCyIiJTFYIiKiLO306dN4+eWXkZqaqnRR7Hb69GkMGzbM5n49evRA/vz5Ubp0abM/Pz8/nD171mj/1NRUvPzyyzhz5oybSk5ElLUwWCIiyiL279+PvHnzKl0Mq5YvX46GDRtm2vVu3LiB7t27Y/ny5boUuA0bNoRKpYJKpUKBAgXQs2dPJCYmuq0MDRs2xPLlyy1u//TTTxEeHo6qVavq/mbOnIn4+HjdcsWKFVGyZEl89dVXRscGBgZi7NixuHnzptlfiRIlzNL+BgQEYPny5ejatSuuX7/ujpdLRJSlMFgiIsriSpcujf3792fa9VQqFW7evCm7rVu3bvjjjz8yrSzvvvsufvjhB1SvXt1o/ZQpUxAXF4djx47h0qVLmDZtml3n279/P0qXLu3SMiYmJuLNN99EZGQkIiIicP78eVy5cgWxsbGIiopCVFQULl++jNu3b2P06NFGx/r5+Vk9t9zsINWrV8cPP/yAHj16uPR1EBFlRQyWiIgo0wQEBJhNgOgu+/btQ5EiRdC4cWOzbTly5EDevHlRvnx5dOjQAadPn86UMsnx8/ODSqXC0aNHERYWhlKlShl1pwsODoZKpcLhw4fNjk1OTsbEiRNlu+HdvXvXYtfDJk2aoGjRotizZ4+7Xx4RkVdjsERElEW1bNkSKpUKt27dQqNGjaBSqfD111/rtu/YsQMvvvgi8ubNi759+yIlJUW3rXTp0ti9ezdGjhyJIkWK4MKFC7ptixcvRsmSJZE7d2507NgRz549AwBUrFhRN6N7eHg4VCoV1q5da1QmS93w1q1bhxdeeAGhoaEYPHgwkpOTAQDjx4/H+++/j4kTJyJv3rwIDw+XDRrkbN26FV26dLG6T0JCAnbs2IFq1aoBANLT0zF48GDkz58fBQsWxJgxYwAADx8+hEqlQqNGjXDr1i1dN76HDx8CANLS0jBq1CgUKVIERYoUwbhx44yuk5iYiE6dOiE4OBivvvoq/v33X902lUoFX19f1KtXDw8fPsTFixfRsmVLrF69Gm+88QYqVaqEDRs2oF69emblX7FiBR4/fizbDS8tLQ3/+9//LL72Ll26ZGorHxGRN2KwRESURa1fvx5xcXEICwvDli1bEBcXh08//RQA8M8//6B9+/YYMmQITp48iRMnTuDbb781On7MmDG4e/cuVq9eret6duHCBQwcOBBLlizBxYsX8ejRI/zwww8AgJMnTyIuLg4AcO7cOcTFxeGtt96yWc6TJ0+iZ8+emDZtGg4dOoRTp07hiy++0G3ftm0brl+/joiICNSrVw8jR4606/XfvXsXpUqVkt02cuRI5M2bF/nz50dCQgLGjh0LAFi4cCE2b96MY8eOYc+ePZg/fz5OnDiBwoULIy4uDlu2bEFYWBji4uIQFxeHwoULAwC+/fZbrF+/Hjt27MDWrVsxf/58bNy4UXe9SZMm4bXXXsO5c+fw9OlTzJs3T7ft2bNnCAwM1C3nypULVatWRePGjfH8+XOcPHkSHTp0MCp/pUqVUKhQIZQuXRpFixZF4cKFZVuXSpUqhXz58mHVqlVm70GpUqVw584du95LIqLsynpnZyIi8lrBwcEAAB8fH+TKlcso+cMvv/yCGjVqoG/fvgCAQYMG4ccffzQaE5MnTx6zm+yyZcvi4cOHCAoKwvHjx6FWq3HlyhUAQO7cuXX7hYSE2J1sYsmSJejevbsuIJgxYwaaNWuGWbNmARDd1BYuXIjAwEC899576N+/v13nDQkJQXx8vOy24cOHo3fv3rh58yY++ugjTJgwAV9//TV69OiBHj16ICkpCefOnYOvry+uXLmCl19+GXnz5kWuXLng4+Nj9tqWLVuGCRMmoEaNGgBEoJo/f37d9ldffRUff/wxAKB9+/ZGQcqTJ09Qo0YNNG/eHPfu3dO1zuXMmRO7du3Ciy++qNt3zpw5aNy4MS5duqRb179/fxQvXlwX8NkrPj4eefLkcegYIqLshsESEVE2dPfuXUREROhu+tPS0szGEn300Udmxz1//hz9+vXDwYMHUb16dfj6+iI9PT1DZblz5w4aNGigWy5btiyeP3+OmJgYAEDdunV1LS8BAQGySQvkVKpUCUePHkWTJk3Mthmm2x4/fjz69OmDr7/+Gjdu3EDv3r3x8OFD1K1bF8HBwXa9vjt37qBMmTK65ddee81ou2HXQ9PX8O+//6Js2bLYsmUL/P394eMjOn20bNkSgwcPRps2bbB//3506NABr776qtm19+7di4ULF9oso6ljx46hcuXKDh9HRJSdsBseEVEW5+PjYxZglChRAm3btsXZs2dx9uxZnDt3Drt27TLaR9syZei7777D06dP8eDBA+zZswevvPKK2T4qlcrugAYASpYsaZTG+vr168iRIwcKFiwIQLQQOaNLly5YsmSJzbTgGo1GFxANGTIErVq1wr1797B+/XqEhoYa7Sv3XgJAWFiYUQbAb775xqilx9JrUKvViIqKQtmyZREYGKgLlEyVLFkSq1evRlBQkNH6hw8f4smTJ+jcuTNCQ0ON/vz9/TFnzhzZ8yUmJmLJkiU2x3QREWV3DJaIiLK4smXLYufOnboABxCBxMGDB/H3338jMDAQc+fORa9evWyeKyEhARqNBjExMVizZg3mz59vFjyULVsW27dvx7179/DXX3/ZPGffvn2xevVqbNy4EVeuXMHQoUPRv39/XXc0ZxUtWhTvvvsuBgwYYLbt+fPniIuLQ0REBL755htdS1BCQgLUajXu3r2LsWPH4uTJk0avr0yZMrh//z4iIiLwzz//ICIiAgDQu3dvjB8/HufOncPp06cxd+5cVKpUyWYZ9+zZAz8/P1SsWNHqfmXKlMEbb7xhtr5IkSKIiYlBbGys2V+xYsV03QJNDRgwAN27d0fx4sVtlpGIKDtjsERElMV9++232Lp1K0qWLInx48cDEAHNypUrMXToUJQrVw6RkZH4+eefbZ7rk08+QUpKCipUqIBly5ahT58+OHv2rNE+8+fPx4wZMxAeHm5X97BatWphxYoVGDFiBOrVq4eaNWti6tSpzrxUM2PHjsWTJ0/Qs2dPaDQa3fpRo0Yhf/78aNq0KcqUKYPFixcDAKZNm4Z169ahWrVqePjwIZo1a6YLiADRIjd16lQ0bdoU1atXx5EjRwAAw4YNw5tvvonmzZujbdu2GDBgALp27WqzfN9//z3atWsHX19f3bq7d+/i5MmTuHbtmllLkjXPnz9HZGQkLly4gLVr1+L+/ftmwZJGo8F7772HJ0+e6D4LRERkmUpypK8EERGRl0lPT8dvv/3mkV3OoqKiEBAQgAoVKujW7d+/H+3atUPNmjWxYcMGuxNlpKamomTJknj69ClKly6NPn36YNiwYWb7/fzzz+jcubNRgEZERPIYLBEREWURqampCAgIULoYRERZBoMlIiIiIiIiGRyzREREREREJIPBEhERERERkQwGS0RERERERDIYLBEREREREclgsERERERERCSDwRIREREREZEMBktEREREREQyGCwRERERERHJYLBEREREREQk4/8vVdOVDCsrKAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练完成！最终测试准确率: 86.30%\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torchvision import datasets, transforms, models\n",
    "from torch.utils.data import DataLoader\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "\n",
    "# 设置中文字体支持\n",
    "plt.rcParams[\"font.family\"] = [\"SimHei\"]\n",
    "plt.rcParams['axes.unicode_minus'] = False  # 解决负号显示问题\n",
    "\n",
    "# 检查GPU是否可用\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"使用设备: {device}\")\n",
    "\n",
    "# 1. 数据预处理（训练集增强，测试集标准化）\n",
    "train_transform = transforms.Compose([\n",
    "    transforms.RandomCrop(32, padding=4),\n",
    "    transforms.RandomHorizontalFlip(),\n",
    "    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),\n",
    "    transforms.RandomRotation(15),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))\n",
    "])\n",
    "\n",
    "test_transform = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))\n",
    "])\n",
    "\n",
    "# 2. 加载CIFAR-10数据集\n",
    "train_dataset = datasets.CIFAR10(\n",
    "    root='./data',\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=train_transform\n",
    ")\n",
    "\n",
    "test_dataset = datasets.CIFAR10(\n",
    "    root='./data',\n",
    "    train=False,\n",
    "    transform=test_transform\n",
    ")\n",
    "\n",
    "# 3. 创建数据加载器\n",
    "batch_size = 64\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "# 4. 定义ResNet18模型\n",
    "def create_resnet18(pretrained=True, num_classes=10):\n",
    "    model = models.resnet18(pretrained=pretrained)\n",
    "    \n",
    "    # 修改最后一层全连接层\n",
    "    in_features = model.fc.in_features\n",
    "    model.fc = nn.Linear(in_features, num_classes)\n",
    "    \n",
    "    return model.to(device)\n",
    "\n",
    "# 5. 冻结/解冻模型层的函数\n",
    "def freeze_model(model, freeze=True):\n",
    "    \"\"\"冻结或解冻模型的卷积层参数\"\"\"\n",
    "    # 冻结/解冻除fc层外的所有参数\n",
    "    for name, param in model.named_parameters():\n",
    "        if 'fc' not in name:\n",
    "            param.requires_grad = not freeze\n",
    "    \n",
    "    # 打印冻结状态\n",
    "    frozen_params = sum(p.numel() for p in model.parameters() if not p.requires_grad)\n",
    "    total_params = sum(p.numel() for p in model.parameters())\n",
    "    \n",
    "    if freeze:\n",
    "        print(f\"已冻结模型卷积层参数 ({frozen_params}/{total_params} 参数)\")\n",
    "    else:\n",
    "        print(f\"已解冻模型所有参数 ({total_params}/{total_params} 参数可训练)\")\n",
    "    \n",
    "    return model\n",
    "\n",
    "# 6. 训练函数（支持阶段式训练）\n",
    "def train_with_freeze_schedule(model, train_loader, test_loader, criterion, optimizer, scheduler, device, epochs, freeze_epochs=5):\n",
    "    \"\"\"\n",
    "    前freeze_epochs轮冻结卷积层，之后解冻所有层进行训练\n",
    "    \"\"\"\n",
    "    train_loss_history = []\n",
    "    test_loss_history = []\n",
    "    train_acc_history = []\n",
    "    test_acc_history = []\n",
    "    all_iter_losses = []\n",
    "    iter_indices = []\n",
    "    \n",
    "    # 初始冻结卷积层\n",
    "    if freeze_epochs > 0:\n",
    "        model = freeze_model(model, freeze=True)\n",
    "    \n",
    "    for epoch in range(epochs):\n",
    "        # 解冻控制：在指定轮次后解冻所有层\n",
    "        if epoch == freeze_epochs:\n",
    "            model = freeze_model(model, freeze=False)\n",
    "            # 解冻后调整优化器（可选）\n",
    "            optimizer.param_groups[0]['lr'] = 1e-4  # 降低学习率防止过拟合\n",
    "        \n",
    "        model.train()  # 设置为训练模式\n",
    "        running_loss = 0.0\n",
    "        correct_train = 0\n",
    "        total_train = 0\n",
    "        \n",
    "        for batch_idx, (data, target) in enumerate(train_loader):\n",
    "            data, target = data.to(device), target.to(device)\n",
    "            optimizer.zero_grad()\n",
    "            output = model(data)\n",
    "            loss = criterion(output, target)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            \n",
    "            # 记录Iteration损失\n",
    "            iter_loss = loss.item()\n",
    "            all_iter_losses.append(iter_loss)\n",
    "            iter_indices.append(epoch * len(train_loader) + batch_idx + 1)\n",
    "            \n",
    "            # 统计训练指标\n",
    "            running_loss += iter_loss\n",
    "            _, predicted = output.max(1)\n",
    "            total_train += target.size(0)\n",
    "            correct_train += predicted.eq(target).sum().item()\n",
    "            \n",
    "            # 每100批次打印进度\n",
    "            if (batch_idx + 1) % 100 == 0:\n",
    "                print(f\"Epoch {epoch+1}/{epochs} | Batch {batch_idx+1}/{len(train_loader)} \"\n",
    "                      f\"| 单Batch损失: {iter_loss:.4f}\")\n",
    "        \n",
    "        # 计算 epoch 级指标\n",
    "        epoch_train_loss = running_loss / len(train_loader)\n",
    "        epoch_train_acc = 100. * correct_train / total_train\n",
    "        \n",
    "        # 测试阶段\n",
    "        model.eval()\n",
    "        correct_test = 0\n",
    "        total_test = 0\n",
    "        test_loss = 0.0\n",
    "        with torch.no_grad():\n",
    "            for data, target in test_loader:\n",
    "                data, target = data.to(device), target.to(device)\n",
    "                output = model(data)\n",
    "                test_loss += criterion(output, target).item()\n",
    "                _, predicted = output.max(1)\n",
    "                total_test += target.size(0)\n",
    "                correct_test += predicted.eq(target).sum().item()\n",
    "        \n",
    "        epoch_test_loss = test_loss / len(test_loader)\n",
    "        epoch_test_acc = 100. * correct_test / total_test\n",
    "        \n",
    "        # 记录历史数据\n",
    "        train_loss_history.append(epoch_train_loss)\n",
    "        test_loss_history.append(epoch_test_loss)\n",
    "        train_acc_history.append(epoch_train_acc)\n",
    "        test_acc_history.append(epoch_test_acc)\n",
    "        \n",
    "        # 更新学习率调度器\n",
    "        if scheduler is not None:\n",
    "            scheduler.step(epoch_test_loss)\n",
    "        \n",
    "        # 打印 epoch 结果\n",
    "        print(f\"Epoch {epoch+1} 完成 | 训练损失: {epoch_train_loss:.4f} \"\n",
    "              f\"| 训练准确率: {epoch_train_acc:.2f}% | 测试准确率: {epoch_test_acc:.2f}%\")\n",
    "    \n",
    "    # 绘制损失和准确率曲线\n",
    "    plot_iter_losses(all_iter_losses, iter_indices)\n",
    "    plot_epoch_metrics(train_acc_history, test_acc_history, train_loss_history, test_loss_history)\n",
    "    \n",
    "    return epoch_test_acc  # 返回最终测试准确率\n",
    "\n",
    "# 7. 绘制Iteration损失曲线\n",
    "def plot_iter_losses(losses, indices):\n",
    "    plt.figure(figsize=(10, 4))\n",
    "    plt.plot(indices, losses, 'b-', alpha=0.7)\n",
    "    plt.xlabel('Iteration（Batch序号）')\n",
    "    plt.ylabel('损失值')\n",
    "    plt.title('训练过程中的Iteration损失变化')\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "# 8. 绘制Epoch级指标曲线\n",
    "def plot_epoch_metrics(train_acc, test_acc, train_loss, test_loss):\n",
    "    epochs = range(1, len(train_acc) + 1)\n",
    "    \n",
    "    plt.figure(figsize=(12, 5))\n",
    "    \n",
    "    # 准确率曲线\n",
    "    plt.subplot(1, 2, 1)\n",
    "    plt.plot(epochs, train_acc, 'b-', label='训练准确率')\n",
    "    plt.plot(epochs, test_acc, 'r-', label='测试准确率')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('准确率 (%)')\n",
    "    plt.title('准确率随Epoch变化')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    \n",
    "    # 损失曲线\n",
    "    plt.subplot(1, 2, 2)\n",
    "    plt.plot(epochs, train_loss, 'b-', label='训练损失')\n",
    "    plt.plot(epochs, test_loss, 'r-', label='测试损失')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('损失值')\n",
    "    plt.title('损失值随Epoch变化')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "# 主函数：训练模型\n",
    "def main():\n",
    "    # 参数设置\n",
    "    epochs = 40  # 总训练轮次\n",
    "    freeze_epochs = 5  # 冻结卷积层的轮次\n",
    "    learning_rate = 1e-3  # 初始学习率\n",
    "    weight_decay = 1e-4  # 权重衰减\n",
    "    \n",
    "    # 创建ResNet18模型（加载预训练权重）\n",
    "    model = create_resnet18(pretrained=True, num_classes=10)\n",
    "    \n",
    "    # 定义优化器和损失函数\n",
    "    optimizer = optim.Adam(model.parameters(), lr=learning_rate, weight_decay=weight_decay)\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    \n",
    "    # 定义学习率调度器\n",
    "    scheduler = optim.lr_scheduler.ReduceLROnPlateau(\n",
    "        optimizer, mode='min', factor=0.5, patience=2, verbose=True\n",
    "    )\n",
    "    \n",
    "    # 开始训练（前5轮冻结卷积层，之后解冻）\n",
    "    final_accuracy = train_with_freeze_schedule(\n",
    "        model=model,\n",
    "        train_loader=train_loader,\n",
    "        test_loader=test_loader,\n",
    "        criterion=criterion,\n",
    "        optimizer=optimizer,\n",
    "        scheduler=scheduler,\n",
    "        device=device,\n",
    "        epochs=epochs,\n",
    "        freeze_epochs=freeze_epochs\n",
    "    )\n",
    "    \n",
    "    print(f\"训练完成！最终测试准确率: {final_accuracy:.2f}%\")\n",
    "    \n",
    "    # # 保存模型\n",
    "    # torch.save(model.state_dict(), 'resnet18_cifar10_finetuned.pth')\n",
    "    # print(\"模型已保存至: resnet18_cifar10_finetuned.pth\")\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "几个明显的现象\n",
    "1. 解冻后几个epoch即可达到之前cnn训练20轮的效果，这是预训练的优势\n",
    "2. 由于训练集用了 RandomCrop（随机裁剪）、RandomHorizontalFlip（随机水平翻转）、ColorJitter（颜色抖动）等数据增强操作，这会让训练时模型看到的图片有更多 “干扰” 或变形。比如一张汽车图片，训练时可能被裁剪成只显示局部、颜色也有变化，模型学习难度更高；而测试集是标准的、没增强的图片，模型预测相对轻松，就可能出现训练集准确率暂时低于测试集的情况，尤其在训练前期增强对模型影响更明显。随着训练推进，模型适应增强后会缓解。\n",
    "3. 最后收敛后的效果超过非预训练模型的80%,大幅提升"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "yolov5",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.20"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
